
function NOR2X0 CELL (QN,IN1,IN2);
output  QN;
input  IN1,IN2;
endfunction

function NOR2X1 CELL (QN,IN1,IN2);
output  QN;
input  IN1,IN2;
endfunction

function NOR2X2 CELL (QN,IN1,IN2);
output  QN;
input  IN1,IN2;
endfunction

function NOR2X4 CELL (QN,IN1,IN2);
output  QN;
input  IN1,IN2;
endfunction

function NOR3X0 CELL (QN,IN1,IN2,IN3);
output  QN;
input  IN1,IN2,IN3;
endfunction

function NOR3X1 CELL (QN,IN1,IN2,IN3);
output  QN;
input  IN1,IN2,IN3;
endfunction

function NOR3X2 CELL (QN,IN1,IN2,IN3);
output  QN;
input  IN1,IN2,IN3;
endfunction

function NOR3X4 CELL (QN,IN1,IN2,IN3);
output  QN;
input  IN1,IN2,IN3;
endfunction

function NOR4X0 CELL (QN,IN1,IN2,IN3,IN4);
output  QN;
input  IN1,IN2,IN3,IN4;
endfunction

function NOR4X1 CELL (QN,IN1,IN2,IN3,IN4);
output  QN;
input  IN1,IN2,IN3,IN4;
endfunction

function AO21X1 CELL (Q,IN1,IN2,IN3);
output  Q;
input  IN1,IN2,IN3;
endfunction

function AO21X2 CELL (Q,IN1,IN2,IN3);
output  Q;
input  IN1,IN2,IN3;
endfunction

function AO221X1 CELL (Q,IN1,IN2,IN3,IN4,IN5);
output  Q;
input  IN1,IN2,IN3,IN4,IN5;
endfunction

function AO221X2 CELL (Q,IN1,IN2,IN3,IN4,IN5);
output  Q;
input  IN1,IN2,IN3,IN4,IN5;
endfunction

function AO222X1 CELL (Q,IN1,IN2,IN3,IN4,IN5,IN6);
output  Q;
input  IN1,IN2,IN3,IN4,IN5,IN6;
endfunction

function AO222X2 CELL (Q,IN1,IN2,IN3,IN4,IN5,IN6);
output  Q;
input  IN1,IN2,IN3,IN4,IN5,IN6;
endfunction

function AO22X1 CELL (Q,IN1,IN2,IN3,IN4);
output  Q;
input  IN1,IN2,IN3,IN4;
endfunction

function AO22X2 CELL (Q,IN1,IN2,IN3,IN4);
output  Q;
input  IN1,IN2,IN3,IN4;
endfunction

function OAI21X1 CELL (QN,IN1,IN2,IN3);
output  QN;
input  IN1,IN2,IN3;
endfunction

function OAI21X2 CELL (QN,IN1,IN2,IN3);
output  QN;
input  IN1,IN2,IN3;
endfunction

function OAI222X1 CELL (QN,IN1,IN2,IN3,IN4,IN5,IN6);
output  QN;
input  IN1,IN2,IN3,IN4,IN5,IN6;
endfunction

function OAI222X2 CELL (QN,IN1,IN2,IN3,IN4,IN5,IN6);
output  QN;
input  IN1,IN2,IN3,IN4,IN5,IN6;
endfunction

function OAI22X1 CELL (QN,IN1,IN2,IN3,IN4);
output  QN;
input  IN1,IN2,IN3,IN4;
endfunction

function OAI22X2 CELL (QN,IN1,IN2,IN3,IN4);
output  QN;
input  IN1,IN2,IN3,IN4;
endfunction

function mc_mcgen_ao1e0 CELL (Y,A,B,C);
output  Y;
input  A,B,C;
endfunction

function mc_mcgen_ao1e1 CELL (Y,A,B,C);
output  Y;
input  A,B,C;
endfunction

function FADDX1 CELL (CO,S,A,B,CI);
output [0:0] CO,S;
input [0:0] A,B,CI;
endfunction

function FADDX2 CELL (CO,S,A,B,CI);
output [0:0] CO,S;
input [0:0] A,B,CI;
endfunction

function HADDX1 CELL (C1,SO,A0,B0);
output [0:0] C1,SO;
input [0:0] A0,B0;
endfunction

function HADDX2 CELL (C1,SO,A0,B0);
output [0:0] C1,SO;
input [0:0] A0,B0;
endfunction

function mc_mcgen_comp4to2a0 CELL (CO1,CO2,S,A,B,C,CI,D);
output [0:0] CO1,CO2,S;
input [0:0] A,B,C,CI,D;
endfunction

function mc_mcgen_comp4to2a0_1 CELL (CO1,CO2,S,A,B,C,CI,D);
output [0:0] CO1,CO2,S;
input [0:0] A,B,C,CI,D;
endfunction

function mc_mcgen_comp4to2a1 CELL (CO1,CO2,S,A,B,C,CI,D);
output [0:0] CO1,CO2,S;
input [0:0] A,B,C,CI,D;
endfunction

function mc_mcgen_comp4to2a1_1 CELL (CO1,CO2,S,A,B,C,CI,D);
output [0:0] CO1,CO2,S;
input [0:0] A,B,C,CI,D;
endfunction

function mc_mcgen_fa1b0 CELL (CO,S,A,B,CI);
output [0:0] CO,S;
input [0:0] A,B,CI;
endfunction

function mc_mcgen_fa1b1 CELL (CO,S,A,B,CI);
output [0:0] CO,S;
input [0:0] A,B,CI;
endfunction

function mc_mcgen_fa1b2 CELL (CO,S,A,B,CI);
output [0:0] CO,S;
input [0:0] A,B,CI;
endfunction

function mc_mcgen_fa1b3 CELL (CO,S,A,B,CI);
output [0:0] CO,S;
input [0:0] A,B,CI;
endfunction

function mc_mcgen_fa2a0 CELL (CO,S,A,B,CI);
output [0:0] CO,S;
input [0:0] A,B,CI;
endfunction

function mc_mcgen_fa2a1 CELL (CO,S,A,B,CI);
output [0:0] CO,S;
input [0:0] A,B,CI;
endfunction

function mc_mcgen_fa2a2 CELL (CO,S,A,B,CI);
output [0:0] CO,S;
input [0:0] A,B,CI;
endfunction

function mc_mcgen_fa2a3 CELL (CO,S,A,B,CI);
output [0:0] CO,S;
input [0:0] A,B,CI;
endfunction

function mc_mcgen_fa2b0 CELL (CO,S,A,B,CI);
output [0:0] CO,S;
input [0:0] A,B,CI;
endfunction

function mc_mcgen_fa2b1 CELL (CO,S,A,B,CI);
output [0:0] CO,S;
input [0:0] A,B,CI;
endfunction

function mc_mcgen_fa2b2 CELL (CO,S,A,B,CI);
output [0:0] CO,S;
input [0:0] A,B,CI;
endfunction

function mc_mcgen_fa2b3 CELL (CO,S,A,B,CI);
output [0:0] CO,S;
input [0:0] A,B,CI;
endfunction

function mc_mcgen_fac1b0 CELL (CO,A,B,CI);
output  CO;
input  A,B,CI;
endfunction

function mc_mcgen_fac1b1 CELL (CO,A,B,CI);
output  CO;
input  A,B,CI;
endfunction

function mc_mcgen_fac2a0 CELL (CO,A,B,CI);
output  CO;
input  A,B,CI;
endfunction

function mc_mcgen_fac2a1 CELL (CO,A,B,CI);
output  CO;
input  A,B,CI;
endfunction

function mc_mcgen_faccs1b0 CELL (CO0,CO1,A,B,CI0,CI1);
output [0:0] CO0,CO1;
input [0:0] A,B,CI0,CI1;
endfunction

function mc_mcgen_faccs1b1 CELL (CO0,CO1,A,B,CI0,CI1);
output [0:0] CO0,CO1;
input [0:0] A,B,CI0,CI1;
endfunction

function mc_mcgen_faccs2a0 CELL (CO0,CO1,A,B,CI0,CI1);
output [0:0] CO0,CO1;
input [0:0] A,B,CI0,CI1;
endfunction

function mc_mcgen_faccs2a1 CELL (CO0,CO1,A,B,CI0,CI1);
output [0:0] CO0,CO1;
input [0:0] A,B,CI0,CI1;
endfunction

function mc_mcgen_faccs3a0 CELL (CO0,CO1,A,B);
output [0:0] CO0,CO1;
input [0:0] A,B;
endfunction

function mc_mcgen_faccs3a1 CELL (CO0,CO1,A,B);
output [0:0] CO0,CO1;
input [0:0] A,B;
endfunction

function mc_mcgen_facs1b0 CELL (CO0,CO1,S,A,B,CI0,CI1,CSIN);
output [0:0] CO0,CO1,S;
input [0:0] A,B,CI0,CI1,CSIN;
endfunction

function mc_mcgen_facs1b0_1 CELL (CO0,CO1,S,A,B,CI0,CI1,CSIN);
output [0:0] CO0,CO1,S;
input [0:0] A,B,CI0,CI1,CSIN;
endfunction

function mc_mcgen_facs1b1 CELL (CO0,CO1,S,A,B,CI0,CI1,CSIN);
output [0:0] CO0,CO1,S;
input [0:0] A,B,CI0,CI1,CSIN;
endfunction

function mc_mcgen_facs1b1_1 CELL (CO0,CO1,S,A,B,CI0,CI1,CSIN);
output [0:0] CO0,CO1,S;
input [0:0] A,B,CI0,CI1,CSIN;
endfunction

function mc_mcgen_facs2a0 CELL (CO0,CO1,S,A,B,CI0,CI1,CSIN);
output [0:0] CO0,CO1,S;
input [0:0] A,B,CI0,CI1,CSIN;
endfunction

function mc_mcgen_facs2a0_1 CELL (CO0,CO1,S,A,B,CI0,CI1,CSIN);
output [0:0] CO0,CO1,S;
input [0:0] A,B,CI0,CI1,CSIN;
endfunction

function mc_mcgen_facs2a1 CELL (CO0,CO1,S,A,B,CI0,CI1,CSIN);
output [0:0] CO0,CO1,S;
input [0:0] A,B,CI0,CI1,CSIN;
endfunction

function mc_mcgen_facs2a1_1 CELL (CO0,CO1,S,A,B,CI0,CI1,CSIN);
output [0:0] CO0,CO1,S;
input [0:0] A,B,CI0,CI1,CSIN;
endfunction

function mc_mcgen_facs3a0 CELL (CO0,CO1,S,A,B,CSIN);
output [0:0] CO0,CO1,S;
input [0:0] A,B,CSIN;
endfunction

function mc_mcgen_facs3a1 CELL (CO0,CO1,S,A,B,CSIN);
output [0:0] CO0,CO1,S;
input [0:0] A,B,CSIN;
endfunction

function mc_mcgen_facs4a0 CELL (CO0,CO1,S,A,B,CSIN);
output [0:0] CO0,CO1,S;
input [0:0] A,B,CSIN;
endfunction

function mc_mcgen_facs4a1 CELL (CO0,CO1,S,A,B,CSIN);
output [0:0] CO0,CO1,S;
input [0:0] A,B,CSIN;
endfunction

function mc_mcgen_ha1b0 CELL (CO,S,A,B);
output [0:0] CO,S;
input [0:0] A,B;
endfunction

function mc_mcgen_ha1b1 CELL (CO,S,A,B);
output [0:0] CO,S;
input [0:0] A,B;
endfunction

function mc_mcgen_ha2a0 CELL (CO,S,A,B);
output [0:0] CO,S;
input [0:0] A,B;
endfunction

function mc_mcgen_ha2a1 CELL (CO,S,A,B);
output [0:0] CO,S;
input [0:0] A,B;
endfunction

function mc_mcgen_ha3a0 CELL (CO,S,A,B);
output [0:0] CO,S;
input [0:0] A,B;
endfunction

function mc_mcgen_ha3a1 CELL (CO,S,A,B);
output [0:0] CO,S;
input [0:0] A,B;
endfunction

function mc_mcgen_ha4a0 CELL (CO,S,A,B);
output [0:0] CO,S;
input [0:0] A,B;
endfunction

function mc_mcgen_ha4a1 CELL (CO,S,A,B);
output [0:0] CO,S;
input [0:0] A,B;
endfunction

function mc_mcgen_hacs1b0 CELL (CO,S,A,B,CSIN);
output [0:0] CO,S;
input [0:0] A,B,CSIN;
endfunction

function mc_mcgen_hacs1b0_1 CELL (CO,S,A,B,CSIN);
output [0:0] CO,S;
input [0:0] A,B,CSIN;
endfunction

function mc_mcgen_hacs1b1 CELL (CO,S,A,B,CSIN);
output [0:0] CO,S;
input [0:0] A,B,CSIN;
endfunction

function mc_mcgen_hacs1b1_1 CELL (CO,S,A,B,CSIN);
output [0:0] CO,S;
input [0:0] A,B,CSIN;
endfunction

function mc_mcgen_hacs2a0 CELL (CO,S,A,B,CSIN);
output [0:0] CO,S;
input [0:0] A,B,CSIN;
endfunction

function mc_mcgen_hacs2a0_1 CELL (CO,S,A,B,CSIN);
output [0:0] CO,S;
input [0:0] A,B,CSIN;
endfunction

function mc_mcgen_hacs2a1 CELL (CO,S,A,B,CSIN);
output [0:0] CO,S;
input [0:0] A,B,CSIN;
endfunction

function mc_mcgen_hacs2a1_1 CELL (CO,S,A,B,CSIN);
output [0:0] CO,S;
input [0:0] A,B,CSIN;
endfunction

function mc_mcgen_hacs3a0 CELL (CO,S,A,CSIN);
output [0:0] CO,S;
input [0:0] A,CSIN;
endfunction

function mc_mcgen_hacs3a1 CELL (CO,S,A,CSIN);
output [0:0] CO,S;
input [0:0] A,CSIN;
endfunction

function AOBUFX1 CELL (Z,INP);
output  Z;
input  INP;
endfunction

function AOBUFX2 CELL (Z,INP);
output  Z;
input  INP;
endfunction

function AOBUFX4 CELL (Z,INP);
output  Z;
input  INP;
endfunction

function DELLN1X2 CELL (Z,INP);
output  Z;
input  INP;
endfunction

function DELLN2X2 CELL (Z,INP);
output  Z;
input  INP;
endfunction

function DELLN3X2 CELL (Z,INP);
output  Z;
input  INP;
endfunction

function HEAD2X16 CELL (SLEEPOUT,SLEEP);
output  SLEEPOUT;
input  SLEEP;
endfunction

function HEAD2X2 CELL (SLEEPOUT,SLEEP);
output  SLEEPOUT;
input  SLEEP;
endfunction

function HEAD2X32 CELL (SLEEPOUT,SLEEP);
output  SLEEPOUT;
input  SLEEP;
endfunction

function HEAD2X4 CELL (SLEEPOUT,SLEEP);
output  SLEEPOUT;
input  SLEEP;
endfunction

function HEAD2X8 CELL (SLEEPOUT,SLEEP);
output  SLEEPOUT;
input  SLEEP;
endfunction

function NBUFFX16 CELL (Z,INP);
output  Z;
input  INP;
endfunction

function NBUFFX2 CELL (Z,INP);
output  Z;
input  INP;
endfunction

function NBUFFX32 CELL (Z,INP);
output  Z;
input  INP;
endfunction

function NBUFFX4 CELL (Z,INP);
output  Z;
input  INP;
endfunction

function NBUFFX8 CELL (Z,INP);
output  Z;
input  INP;
endfunction

function TNBUFFX1 CELL (Z,ENB,INP);
output  Z;
input fb  ENB;
input  INP;
endfunction

function TNBUFFX16 CELL (Z,ENB,INP);
output  Z;
input fb  ENB;
input  INP;
endfunction

function TNBUFFX2 CELL (Z,ENB,INP);
output  Z;
input fb  ENB;
input  INP;
endfunction

function TNBUFFX32 CELL (Z,ENB,INP);
output  Z;
input fb  ENB;
input  INP;
endfunction

function TNBUFFX4 CELL (Z,ENB,INP);
output  Z;
input fb  ENB;
input  INP;
endfunction

function TNBUFFX8 CELL (Z,ENB,INP);
output  Z;
input fb  ENB;
input  INP;
endfunction

function AODFFARX1 CELL (Q,QN,CLK,D,RSTB);
output [0:0] Q,QN;
input [0:0] CLK;
input fb [0:0] D,RSTB;
endfunction

function AODFFARX2 CELL (Q,QN,CLK,D,RSTB);
output [0:0] Q,QN;
input [0:0] CLK;
input fb [0:0] D,RSTB;
endfunction

function DFFARX1 CELL (Q,QN,CLK,D,RSTB);
output [0:0] Q,QN;
input [0:0] CLK;
input fb [0:0] D,RSTB;
endfunction

function DFFARX2 CELL (Q,QN,CLK,D,RSTB);
output [0:0] Q,QN;
input [0:0] CLK;
input fb [0:0] D,RSTB;
endfunction

function DFFASRX1 CELL (Q,QN,CLK,D,RSTB,SETB);
output [0:0] Q,QN;
input [0:0] CLK;
input fb [0:0] D,RSTB,SETB;
endfunction

function DFFASRX2 CELL (Q,QN,CLK,D,RSTB,SETB);
output [0:0] Q,QN;
input [0:0] CLK;
input fb [0:0] D,RSTB,SETB;
endfunction

function DFFASX1 CELL (Q,QN,CLK,D,SETB);
output [0:0] Q,QN;
input [0:0] CLK;
input fb [0:0] D,SETB;
endfunction

function DFFASX2 CELL (Q,QN,CLK,D,SETB);
output [0:0] Q,QN;
input [0:0] CLK;
input fb [0:0] D,SETB;
endfunction

function DFFNASRQX1 CELL (Q,CLK,D,RSTB,SETB);
output  Q;
input  CLK;
input fb  D,RSTB,SETB;
endfunction

function DFFNASRQX2 CELL (Q,CLK,D,RSTB,SETB);
output  Q;
input  CLK;
input fb  D,RSTB,SETB;
endfunction

function DFFX1 CELL (Q,QN,CLK,D);
output [0:0] Q,QN;
input [0:0] CLK;
input fb [0:0] D;
endfunction

function DFFX2 CELL (Q,QN,CLK,D);
output [0:0] Q,QN;
input [0:0] CLK;
input fb [0:0] D;
endfunction

function SDFFARX1 CELL (Q,QN,CLK,D,RSTB,SE,SI);
output [0:0] Q,QN;
input [0:0] CLK;
input fb [0:0] D,RSTB,SE,SI;
endfunction

function SDFFARX2 CELL (Q,QN,CLK,D,RSTB,SE,SI);
output [0:0] Q,QN;
input [0:0] CLK;
input fb [0:0] D,RSTB,SE,SI;
endfunction

function mc_mcgen_fde1a0 CELL (Q,CLK,D,E);
output  Q;
input fb  CLK,D,E;
endfunction

function mc_mcgen_fde1a1 CELL (Q,CLK,D,E);
output  Q;
input fb  CLK,D,E;
endfunction

function mc_mcgen_fde2a0 CELL (Q,CLK,CLR,D,E);
output  Q;
input fb  CLK,CLR,D,E;
endfunction

function mc_mcgen_fde2a1 CELL (Q,CLK,CLR,D,E);
output  Q;
input fb  CLK,CLR,D,E;
endfunction

function mc_mcgen_fde3a0 CELL (Q,CLK,D,E,PRE);
output  Q;
input fb  CLK,D,E,PRE;
endfunction

function mc_mcgen_fde3a1 CELL (Q,CLK,D,E,PRE);
output  Q;
input fb  CLK,D,E,PRE;
endfunction

function mc_mcgen_fde4a0 CELL (Q,CLK,CLR,D,E,PRE);
output  Q;
input fb  CLK,CLR,D,E,PRE;
endfunction

function mc_mcgen_fde4a1 CELL (Q,CLK,CLR,D,E,PRE);
output  Q;
input fb  CLK,CLR,D,E,PRE;
endfunction

function mc_mcgen_fdei1a0 CELL (Q,CLK,D,E);
output  Q;
input fb  CLK,D,E;
endfunction

function mc_mcgen_fdei1a1 CELL (Q,CLK,D,E);
output  Q;
input fb  CLK,D,E;
endfunction

function mc_mcgen_fdei2a0 CELL (Q,CLK,CLR,D,E);
output  Q;
input fb  CLK,CLR,D,E;
endfunction

function mc_mcgen_fdei2a1 CELL (Q,CLK,CLR,D,E);
output  Q;
input fb  CLK,CLR,D,E;
endfunction

function mc_mcgen_fdei3a0 CELL (Q,CLK,D,E,PRE);
output  Q;
input fb  CLK,D,E,PRE;
endfunction

function mc_mcgen_fdei3a1 CELL (Q,CLK,D,E,PRE);
output  Q;
input fb  CLK,D,E,PRE;
endfunction

function mc_mcgen_fdei4a0 CELL (Q,CLK,CLR,D,E,PRE);
output  Q;
input fb  CLK,CLR,D,E,PRE;
endfunction

function mc_mcgen_fdei4a1 CELL (Q,CLK,CLR,D,E,PRE);
output  Q;
input fb  CLK,CLR,D,E,PRE;
endfunction

function AOINVX1 CELL (ZN,INP);
output  ZN;
input  INP;
endfunction

function AOINVX2 CELL (ZN,INP);
output  ZN;
input  INP;
endfunction

function AOINVX4 CELL (ZN,INP);
output  ZN;
input  INP;
endfunction

function IBUFFX16 CELL (ZN,INP);
output  ZN;
input  INP;
endfunction

function IBUFFX2 CELL (ZN,INP);
output  ZN;
input  INP;
endfunction

function IBUFFX32 CELL (ZN,INP);
output  ZN;
input  INP;
endfunction

function IBUFFX4 CELL (ZN,INP);
output  ZN;
input  INP;
endfunction

function IBUFFX8 CELL (ZN,INP);
output  ZN;
input  INP;
endfunction

function INVX0 CELL (ZN,INP);
output  ZN;
input  INP;
endfunction

function INVX1 CELL (ZN,INP);
output  ZN;
input  INP;
endfunction

function INVX16 CELL (ZN,INP);
output  ZN;
input  INP;
endfunction

function INVX2 CELL (ZN,INP);
output  ZN;
input  INP;
endfunction

function INVX32 CELL (ZN,INP);
output  ZN;
input  INP;
endfunction

function INVX4 CELL (ZN,INP);
output  ZN;
input  INP;
endfunction

function INVX8 CELL (ZN,INP);
output  ZN;
input  INP;
endfunction

function LASRQX1 CELL (Q,CLK,D,RSTB,SETB);
output  Q;
input  CLK,D;
input fb  RSTB,SETB;
endfunction

function LASRQX2 CELL (Q,CLK,D,RSTB,SETB);
output  Q;
input  CLK,D;
input fb  RSTB,SETB;
endfunction

function MUX21X1 CELL (Q,IN1,IN2,S);
output  Q;
input  IN1,IN2,S;
endfunction

function MUX21X2 CELL (Q,IN1,IN2,S);
output  Q;
input  IN1,IN2,S;
endfunction

function MUX41X1 CELL (Q,IN1,IN2,IN3,IN4,S0,S1);
output  Q;
input  IN1,IN2,IN3,IN4,S0,S1;
endfunction

function MUX41X2 CELL (Q,IN1,IN2,IN3,IN4,S0,S1);
output  Q;
input  IN1,IN2,IN3,IN4,S0,S1;
endfunction

function mc_mcgen_mx2d0 CELL (Y,D0,D1,S);
output  Y;
input  D0,D1,S;
endfunction

function mc_mcgen_mx2d1 CELL (Y,D0,D1,S);
output  Y;
input  D0,D1,S;
endfunction

function mc_mcgen_mx3a0 CELL (Y,D0,D1,D2,S0,S1);
output  Y;
input  D0,D1,D2,S0,S1;
endfunction

function mc_mcgen_mx3a1 CELL (Y,D0,D1,D2,S0,S1);
output  Y;
input  D0,D1,D2,S0,S1;
endfunction

function mc_mcgen_mx3d0 CELL (Y,D0,D1,D2,S0,S1);
output  Y;
input  D0,D1,D2,S0,S1;
endfunction

function mc_mcgen_mx3d1 CELL (Y,D0,D1,D2,S0,S1);
output  Y;
input  D0,D1,D2,S0,S1;
endfunction

function mc_mcgen_mx4d0 CELL (Y,D0,D1,D2,D3,S0,S1);
output  Y;
input  D0,D1,D2,D3,S0,S1;
endfunction

function mc_mcgen_mx4d1 CELL (Y,D0,D1,D2,D3,S0,S1);
output  Y;
input  D0,D1,D2,D3,S0,S1;
endfunction

function mc_mcgen_mule2a0 CELL (M,S,Z,A,B,C);
output [0:0] M,S,Z;
input [0:0] A,B,C;
endfunction

function mc_mcgen_mule2a1 CELL (M,S,Z,A,B,C);
output [0:0] M,S,Z;
input [0:0] A,B,C;
endfunction

function mc_mcgen_mulpa1b0 CELL (P,M,S,X0,X1,Z);
output  P;
input  M,S,X0,X1,Z;
endfunction

function mc_mcgen_mulpa1b1 CELL (P,M,S,X0,X1,Z);
output  P;
input  M,S,X0,X1,Z;
endfunction

function mc_mcgen_mulpa2b0 CELL (P,M,S,X0,X1,Z);
output  P;
input  M,S,X0,X1,Z;
endfunction

function mc_mcgen_mulpa2b1 CELL (P,M,S,X0,X1,Z);
output  P;
input  M,S,X0,X1,Z;
endfunction

function ISOLORX1 CELL (Q,D,ISO);
output  Q;
input  D,ISO;
endfunction

function ISOLORX2 CELL (Q,D,ISO);
output  Q;
input  D,ISO;
endfunction

function ISOLORX4 CELL (Q,D,ISO);
output  Q;
input  D,ISO;
endfunction

function ISOLORX8 CELL (Q,D,ISO);
output  Q;
input  D,ISO;
endfunction

function OR2X1 CELL (Q,IN1,IN2);
output  Q;
input  IN1,IN2;
endfunction

function OR2X2 CELL (Q,IN1,IN2);
output  Q;
input  IN1,IN2;
endfunction

function OR2X4 CELL (Q,IN1,IN2);
output  Q;
input  IN1,IN2;
endfunction

function OR3X1 CELL (Q,IN1,IN2,IN3);
output  Q;
input  IN1,IN2,IN3;
endfunction

function OR3X2 CELL (Q,IN1,IN2,IN3);
output  Q;
input  IN1,IN2,IN3;
endfunction

function OR3X4 CELL (Q,IN1,IN2,IN3);
output  Q;
input  IN1,IN2,IN3;
endfunction

function OR4X1 CELL (Q,IN1,IN2,IN3,IN4);
output  Q;
input  IN1,IN2,IN3,IN4;
endfunction

function OR4X2 CELL (Q,IN1,IN2,IN3,IN4);
output  Q;
input  IN1,IN2,IN3,IN4;
endfunction

function OR4X4 CELL (Q,IN1,IN2,IN3,IN4);
output  Q;
input  IN1,IN2,IN3,IN4;
endfunction

function AND2X1 CELL (Q,IN1,IN2);
output  Q;
input  IN1,IN2;
endfunction

function AND2X2 CELL (Q,IN1,IN2);
output  Q;
input  IN1,IN2;
endfunction

function AND2X4 CELL (Q,IN1,IN2);
output  Q;
input  IN1,IN2;
endfunction

function AND3X1 CELL (Q,IN1,IN2,IN3);
output  Q;
input  IN1,IN2,IN3;
endfunction

function AND3X2 CELL (Q,IN1,IN2,IN3);
output  Q;
input  IN1,IN2,IN3;
endfunction

function AND3X4 CELL (Q,IN1,IN2,IN3);
output  Q;
input  IN1,IN2,IN3;
endfunction

function AND4X1 CELL (Q,IN1,IN2,IN3,IN4);
output  Q;
input  IN1,IN2,IN3,IN4;
endfunction

function AND4X2 CELL (Q,IN1,IN2,IN3,IN4);
output  Q;
input  IN1,IN2,IN3,IN4;
endfunction

function AND4X4 CELL (Q,IN1,IN2,IN3,IN4);
output  Q;
input  IN1,IN2,IN3,IN4;
endfunction

function ISOLANDX1 CELL (Q,D,ISO);
output  Q;
input  D,ISO;
endfunction

function ISOLANDX2 CELL (Q,D,ISO);
output  Q;
input  D,ISO;
endfunction

function ISOLANDX4 CELL (Q,D,ISO);
output  Q;
input  D,ISO;
endfunction

function ISOLANDX8 CELL (Q,D,ISO);
output  Q;
input  D,ISO;
endfunction

function NAND2X0 CELL (QN,IN1,IN2);
output  QN;
input  IN1,IN2;
endfunction

function NAND2X1 CELL (QN,IN1,IN2);
output  QN;
input  IN1,IN2;
endfunction

function NAND2X2 CELL (QN,IN1,IN2);
output  QN;
input  IN1,IN2;
endfunction

function NAND2X4 CELL (QN,IN1,IN2);
output  QN;
input  IN1,IN2;
endfunction

function NAND3X0 CELL (QN,IN1,IN2,IN3);
output  QN;
input  IN1,IN2,IN3;
endfunction

function NAND3X1 CELL (QN,IN1,IN2,IN3);
output  QN;
input  IN1,IN2,IN3;
endfunction

function NAND3X2 CELL (QN,IN1,IN2,IN3);
output  QN;
input  IN1,IN2,IN3;
endfunction

function NAND3X4 CELL (QN,IN1,IN2,IN3);
output  QN;
input  IN1,IN2,IN3;
endfunction

function NAND4X0 CELL (QN,IN1,IN2,IN3,IN4);
output  QN;
input  IN1,IN2,IN3,IN4;
endfunction

function NAND4X1 CELL (QN,IN1,IN2,IN3,IN4);
output  QN;
input  IN1,IN2,IN3,IN4;
endfunction

function mc_mcgen_or2b0 CELL (Y,A,B);
output  Y;
input  A,B;
endfunction

function mc_mcgen_or2b1 CELL (Y,A,B);
output  Y;
input  A,B;
endfunction

function mc_mcgen_or2d0 CELL (Y,A,B);
output  Y;
input  A,B;
endfunction

function mc_mcgen_or2d1 CELL (Y,A,B);
output  Y;
input  A,B;
endfunction

function AOI21X1 CELL (QN,IN1,IN2,IN3);
output  QN;
input  IN1,IN2,IN3;
endfunction

function AOI21X2 CELL (QN,IN1,IN2,IN3);
output  QN;
input  IN1,IN2,IN3;
endfunction

function AOI222X1 CELL (QN,IN1,IN2,IN3,IN4,IN5,IN6);
output  QN;
input  IN1,IN2,IN3,IN4,IN5,IN6;
endfunction

function AOI222X2 CELL (QN,IN1,IN2,IN3,IN4,IN5,IN6);
output  QN;
input  IN1,IN2,IN3,IN4,IN5,IN6;
endfunction

function AOI22X1 CELL (QN,IN1,IN2,IN3,IN4);
output  QN;
input  IN1,IN2,IN3,IN4;
endfunction

function AOI22X2 CELL (QN,IN1,IN2,IN3,IN4);
output  QN;
input  IN1,IN2,IN3,IN4;
endfunction

function OA21X1 CELL (Q,IN1,IN2,IN3);
output  Q;
input  IN1,IN2,IN3;
endfunction

function OA21X2 CELL (Q,IN1,IN2,IN3);
output  Q;
input  IN1,IN2,IN3;
endfunction

function OA221X1 CELL (Q,IN1,IN2,IN3,IN4,IN5);
output  Q;
input  IN1,IN2,IN3,IN4,IN5;
endfunction

function OA221X2 CELL (Q,IN1,IN2,IN3,IN4,IN5);
output  Q;
input  IN1,IN2,IN3,IN4,IN5;
endfunction

function OA222X1 CELL (Q,IN1,IN2,IN3,IN4,IN5,IN6);
output  Q;
input  IN1,IN2,IN3,IN4,IN5,IN6;
endfunction

function OA222X2 CELL (Q,IN1,IN2,IN3,IN4,IN5,IN6);
output  Q;
input  IN1,IN2,IN3,IN4,IN5,IN6;
endfunction

function OA22X1 CELL (Q,IN1,IN2,IN3,IN4);
output  Q;
input  IN1,IN2,IN3,IN4;
endfunction

function OA22X2 CELL (Q,IN1,IN2,IN3,IN4);
output  Q;
input  IN1,IN2,IN3,IN4;
endfunction

function XNOR2X1 CELL (Q,IN1,IN2);
output  Q;
input  IN1,IN2;
endfunction

function XNOR2X2 CELL (Q,IN1,IN2);
output  Q;
input  IN1,IN2;
endfunction

function XNOR3X1 CELL (Q,IN1,IN2,IN3);
output  Q;
input  IN1,IN2,IN3;
endfunction

function XNOR3X2 CELL (Q,IN1,IN2,IN3);
output  Q;
input  IN1,IN2,IN3;
endfunction

function XOR2X1 CELL (Q,IN1,IN2);
output  Q;
input  IN1,IN2;
endfunction

function XOR2X2 CELL (Q,IN1,IN2);
output  Q;
input  IN1,IN2;
endfunction

function XOR3X1 CELL (Q,IN1,IN2,IN3);
output  Q;
input  IN1,IN2,IN3;
endfunction

function XOR3X2 CELL (Q,IN1,IN2,IN3);
output  Q;
input  IN1,IN2,IN3;
endfunction

function mc_mcgen_xnor4a0 CELL (Y,A,B,C,D);
output  Y;
input  A,B,C,D;
endfunction

function mc_mcgen_xnor4a1 CELL (Y,A,B,C,D);
output  Y;
input  A,B,C,D;
endfunction

function mc_mcgen_xor4a0 CELL (Y,A,B,C,D);
output  Y;
input  A,B,C,D;
endfunction

function mc_mcgen_xor4a1 CELL (Y,A,B,C,D);
output  Y;
input  A,B,C,D;
endfunction

function mcgen_and2a  (Y,A,B);
output  Y;
input  A,B;
	AND2X4 (Y,A,B);
endfunction

function mcgen_and2b  (Y,A,B);
output  Y;
input  A,B;
	ISOLANDX8 (Y,B,A);
endfunction

function mcgen_and2c  (Y,A,B);
output  Y;
input  A,B;
	NOR2X4 (Y,A,B);
endfunction

function mcgen_and2d  (Y,A,B);
output  Y;
input  A,B;
	ISOLANDX8 (Y,A,B);
endfunction

function mcgen_and3a  (Y,A,B,C);
output  Y;
input  A,B,C;
	AND3X4 (Y,A,B,C);
endfunction

function mcgen_and3b  (Y,A,B,C);
output  Y;
input  A,B,C;
	Y=~A&B&C;
warning("mcgen_and3b is not instantiated\n");
endfunction

function mcgen_and3c  (Y,A,B,C);
output  Y;
input  A,B,C;
	Y=~A&~B&C;
warning("mcgen_and3c is not instantiated\n");
endfunction

function mcgen_and3d  (Y,A,B,C);
output  Y;
input  A,B,C;
	NOR3X4 (Y,A,B,C);
endfunction

function mcgen_and4a  (Y,A,B,C,D);
output  Y;
input  A,B,C,D;
	AND4X4 (Y,A,B,C,D);
endfunction

function mcgen_and4b  (Y,A,B,C,D);
output  Y;
input  A,B,C,D;
	Y=~A&B&C&D;
warning("mcgen_and4b is not instantiated\n");
endfunction

function mcgen_and4c  (Y,A,B,C,D);
output  Y;
input  A,B,C,D;
	Y=~A&~B&C&D;
warning("mcgen_and4c is not instantiated\n");
endfunction

function mcgen_and4d  (Y,A,B,C,D);
output  Y;
input  A,B,C,D;
	Y=~A&~B&~C&D;
warning("mcgen_and4d is not instantiated\n");
endfunction

function mcgen_and4e  (Y,A,B,C,D);
output  Y;
input  A,B,C,D;
	NOR4X1 (Y,A,B,C,D);
endfunction

function mcgen_and5a  (Y,A,B,C,D,E);
output  Y;
input  A,B,C,D,E;
	Y=A&B&C&D&E;
warning("mcgen_and5a is not instantiated\n");
endfunction

function mcgen_and5b  (Y,A,B,C,D,E);
output  Y;
input  A,B,C,D,E;
	Y=~A&B&C&D&E;
warning("mcgen_and5b is not instantiated\n");
endfunction

function mcgen_and5c  (Y,A,B,C,D,E);
output  Y;
input  A,B,C,D,E;
	Y=~A&~B&C&D&E;
warning("mcgen_and5c is not instantiated\n");
endfunction

function mcgen_and5d  (Y,A,B,C,D,E);
output  Y;
input  A,B,C,D,E;
	Y=~A&~B&~C&D&E;
warning("mcgen_and5d is not instantiated\n");
endfunction

function mcgen_and5e  (Y,A,B,C,D,E);
output  Y;
input  A,B,C,D,E;
	Y=~A&~B&~C&~D&E;
warning("mcgen_and5e is not instantiated\n");
endfunction

function mcgen_and5f  (Y,A,B,C,D,E);
output  Y;
input  A,B,C,D,E;
	Y=~A&~B&~C&~D&~E;
warning("mcgen_and5f is not instantiated\n");
endfunction

function mcgen_and6a  (Y,A,B,C,D,E,F);
output  Y;
input  A,B,C,D,E,F;
	Y=A&B&C&D&E&F;
warning("mcgen_and6a is not instantiated\n");
endfunction

function mcgen_and6g  (Y,A,B,C,D,E,F);
output  Y;
input  A,B,C,D,E,F;
	Y=~A&~B&~C&~D&~E&~F;
warning("mcgen_and6g is not instantiated\n");
endfunction

function mcgen_and7a  ();
warning("mcgen_and7a is not instantiated\n");
endfunction

function mcgen_and8a  (Y,A,B,C,D,E,F,G,H);
output  Y;
input  A,B,C,D,E,F,G,H;
	Y=A&B&C&D&E&F&G&H;
warning("mcgen_and8a is not instantiated\n");
endfunction

function mcgen_and8i  (Y,A,B,C,D,E,F,G,H);
output  Y;
input  A,B,C,D,E,F,G,H;
	Y=~A&~B&~C&~D&~E&~F&~G&~H;
warning("mcgen_and8i is not instantiated\n");
endfunction

function mcgen_ao1a  (Y,A,B,C);
output  Y;
input  A,B,C;
	AO21X2 (Y,A,B,C);
endfunction

function mcgen_ao1b  (Y,A,B,C);
output  Y;
input  A,B,C;
	Y=(~A&B)|C;
warning("mcgen_ao1b is not instantiated\n");
endfunction

function mcgen_ao1c  (Y,A,B,C);
output  Y;
input  A,B,C;
	Y=(~A&~B)|C;
warning("mcgen_ao1c is not instantiated\n");
endfunction

function mcgen_ao1d  (Y,A,B,C);
output  Y;
input  A,B,C;
	Y=(A&B)|~C;
warning("mcgen_ao1d is not instantiated\n");
endfunction

function mcgen_ao1e  (Y,A,B,C);
output  Y;
input  A,B,C;
	mc_mcgen_ao1e1 (Y,A,B,C);
endfunction

function mcgen_ao1f  (Y,A,B,C);
output  Y;
input  A,B,C;
	OAI21X2 (Y,A,B,C);
endfunction

function mcgen_ao2a  (Y,A,B,C,D);
output  Y;
input  A,B,C,D;
	Y=(A&B)|C|D;
warning("mcgen_ao2a is not instantiated\n");
endfunction

function mcgen_ao2b  (Y,A,B,C,D);
output  Y;
input  A,B,C,D;
	Y=(~A&B)|C|D;
warning("mcgen_ao2b is not instantiated\n");
endfunction

function mcgen_ao2c  (Y,A,B,C,D);
output  Y;
input  A,B,C,D;
	Y=(~A&~B)|C|D;
warning("mcgen_ao2c is not instantiated\n");
endfunction

function mcgen_ao2d  (Y,A,B,C,D);
output  Y;
input  A,B,C,D;
	Y=(A&B)|~C|D;
warning("mcgen_ao2d is not instantiated\n");
endfunction

function mcgen_ao2e  (Y,A,B,C,D);
output  Y;
input  A,B,C,D;
	Y=(~A&B)|~C|D;
warning("mcgen_ao2e is not instantiated\n");
endfunction

function mcgen_ao2f  (Y,A,B,C,D);
output  Y;
input  A,B,C,D;
	Y=(~A&~B)|~C|D;
warning("mcgen_ao2f is not instantiated\n");
endfunction

function mcgen_ao2g  (Y,A,B,C,D);
output  Y;
input  A,B,C,D;
	Y=(A&B)|~C|~D;
warning("mcgen_ao2g is not instantiated\n");
endfunction

function mcgen_ao2h  (Y,A,B,C,D);
output  Y;
input  A,B,C,D;
	Y=(~A&B)|~C|~D;
warning("mcgen_ao2h is not instantiated\n");
endfunction

function mcgen_ao2i  (Y,A,B,C,D);
output  Y;
input  A,B,C,D;
	Y=(~A&~B)|~C|~D;
warning("mcgen_ao2i is not instantiated\n");
endfunction

function mcgen_ao3a  (Y,A,B,C,D);
output  Y;
input  A,B,C,D;
	Y=(A&B&C)|D;
warning("mcgen_ao3a is not instantiated\n");
endfunction

function mcgen_ao3b  (Y,A,B,C,D);
output  Y;
input  A,B,C,D;
	Y=(~A&B&C)|D;
warning("mcgen_ao3b is not instantiated\n");
endfunction

function mcgen_ao3c  (Y,A,B,C,D);
output  Y;
input  A,B,C,D;
	Y=(~A&~B&C)|D;
warning("mcgen_ao3c is not instantiated\n");
endfunction

function mcgen_ao3d  (Y,A,B,C,D);
output  Y;
input  A,B,C,D;
	Y=(~A&~B&~C)|D;
warning("mcgen_ao3d is not instantiated\n");
endfunction

function mcgen_ao3e  (Y,A,B,C,D);
output  Y;
input  A,B,C,D;
	Y=(A&B&C)|~D;
warning("mcgen_ao3e is not instantiated\n");
endfunction

function mcgen_ao3f  (Y,A,B,C,D);
output  Y;
input  A,B,C,D;
	Y=(~A&B&C)|~D;
warning("mcgen_ao3f is not instantiated\n");
endfunction

function mcgen_ao3g  (Y,A,B,C,D);
output  Y;
input  A,B,C,D;
	Y=(~A&~B&C)|~D;
warning("mcgen_ao3g is not instantiated\n");
endfunction

function mcgen_ao3h  (Y,A,B,C,D);
output  Y;
input  A,B,C,D;
	Y=(~A&~B&~C)|~D;
warning("mcgen_ao3h is not instantiated\n");
endfunction

function mcgen_ao4a  (Y,A,B,C,D);
output  Y;
input  A,B,C,D;
	AO22X2 (Y,A,B,C,D);
endfunction

function mcgen_ao4b  (Y,A,B,C,D);
output  Y;
input  A,B,C,D;
	Y=(~A&B)|(C&D);
warning("mcgen_ao4b is not instantiated\n");
endfunction

function mcgen_ao4c  (Y,A,B,C,D);
output  Y;
input  A,B,C,D;
	Y=(~A&~B)|(C&D);
warning("mcgen_ao4c is not instantiated\n");
endfunction

function mcgen_ao4d  (Y,A,B,C,D);
output  Y;
input  A,B,C,D;
	Y=(~A&B)|(~C&D);
warning("mcgen_ao4d is not instantiated\n");
endfunction

function mcgen_ao4e  (Y,A,B,C,D);
output  Y;
input  A,B,C,D;
	Y=(~A&B)|(~C&~D);
warning("mcgen_ao4e is not instantiated\n");
endfunction

function mcgen_ao4f  (Y,A,B,C,D);
output  Y;
input  A,B,C,D;
	OAI22X2 (Y,A,B,C,D);
endfunction

function mcgen_ao5a  (Y,A,B,C,D,E);
output  Y;
input  A,B,C,D,E;
	Y=(A&B&C) | (D&E);
warning("mcgen_ao5a is not instantiated\n");
endfunction

function mcgen_ao5b  (Y,A,B,C,D,E);
output  Y;
input  A,B,C,D,E;
	Y=(~A&B&C) | (D&E);
warning("mcgen_ao5b is not instantiated\n");
endfunction

function mcgen_ao6a  (Y,A,B,C);
output  Y;
input  A,B,C;
	Y=(A&B) | (A&C) | (B&C);
warning("mcgen_ao6a is not instantiated\n");
endfunction

function mcgen_ao7a  (Y,A,B,C,D,E,F);
output  Y;
input  A,B,C,D,E,F;
	AO222X2 (Y,A,B,C,D,E,F);
endfunction

function mcgen_ao7g  (Y,A,B,C,D,E,F);
output  Y;
input  A,B,C,D,E,F;
	OAI222X2 (Y,A,B,C,D,E,F);
endfunction

function mcgen_ao8a  (Y,A,B,C,D,E);
output  Y;
input  A,B,C,D,E;
	AO221X2 (Y,A,B,C,D,E);
endfunction

function mcgen_ax1a  (Y,A,B,C);
output  Y;
input  A,B,C;
	Y=(A&B) ^ C;
warning("mcgen_ax1a is not instantiated\n");
endfunction

function mcgen_buf1a  (Y,A);
output  Y;
input  A;
	AOBUFX4 (Y,A);
endfunction

function mcgen_buf2a  (Y,YN,A);
output [0:0] Y,YN;
input [0:0] A;
	Y=A;
	YN=~A;
warning("mcgen_buf2a is not instantiated\n");
endfunction

function mcgen_comp4to2a  (CO1,CO2,S,A,B,C,CI,D);
output [0:0] CO1,CO2,S;
input [0:0] A,B,C,CI,D;
	mc_mcgen_comp4to2a1_1 (CO1,CO2,S,A,B,C,CI,D);
endfunction

function mcgen_fa1a  (CO,S,A,B,CI);
output [0:0] CO,S;
input [0:0] A,B,CI;
	FADDX2 (CO,S,A,B,CI);
endfunction

function mcgen_fa1b  (CO,S,A,B,CI);
output [0:0] CO,S;
input [0:0] A,B,CI;
	mc_mcgen_fa1b1 (CO,S,A,B,CI);
endfunction

function mcgen_fa2a  (CO,S,A,B,CI);
output [0:0] CO,S;
input [0:0] A,B,CI;
	mc_mcgen_fa2a1 (CO,S,A,B,CI);
endfunction

function mcgen_fa2b  (CO,S,A,B,CI);
output [0:0] CO,S;
input [0:0] A,B,CI;
	mc_mcgen_fa2b1 (CO,S,A,B,CI);
endfunction

function mcgen_fac1b  (CO,A,B,CI);
output  CO;
input  A,B,CI;
	mc_mcgen_fac1b1 (CO,A,B,CI);
endfunction

function mcgen_fac2a  (CO,A,B,CI);
output  CO;
input  A,B,CI;
	mc_mcgen_fac2a1 (CO,A,B,CI);
endfunction

function mcgen_faccs1b  (CO0,CO1,A,B,CI0,CI1);
output [0:0] CO0,CO1;
input [0:0] A,B,CI0,CI1;
	mc_mcgen_faccs1b1 (CO0,CO1,A,B,CI0,CI1);
endfunction

function mcgen_faccs2a  (CO0,CO1,A,B,CI0,CI1);
output [0:0] CO0,CO1;
input [0:0] A,B,CI0,CI1;
	mc_mcgen_faccs2a1 (CO0,CO1,A,B,CI0,CI1);
endfunction

function mcgen_faccs3a  (CO0,CO1,A,B);
output [0:0] CO0,CO1;
input [0:0] A,B;
	mc_mcgen_faccs3a1 (CO0,CO1,A,B);
endfunction

function mcgen_facs1b  (CO0,CO1,S,A,B,CI0,CI1,CSIN);
output [0:0] CO0,CO1,S;
input [0:0] A,B,CI0,CI1,CSIN;
	mc_mcgen_facs1b1_1 (CO0,CO1,S,A,B,CI0,CI1,CSIN);
endfunction

function mcgen_facs2a  (CO0,CO1,S,A,B,CI0,CI1,CSIN);
output [0:0] CO0,CO1,S;
input [0:0] A,B,CI0,CI1,CSIN;
	mc_mcgen_facs2a1_1 (CO0,CO1,S,A,B,CI0,CI1,CSIN);
endfunction

function mcgen_facs3a  (CO0,CO1,S,A,B,CSIN);
output [0:0] CO0,CO1,S;
input [0:0] A,B,CSIN;
	mc_mcgen_facs3a1 (CO0,CO1,S,A,B,CSIN);
endfunction

function mcgen_facs4a  (CO0,CO1,S,A,B,CSIN);
output [0:0] CO0,CO1,S;
input [0:0] A,B,CSIN;
	mc_mcgen_facs4a1 (CO0,CO1,S,A,B,CSIN);
endfunction

function mcgen_fd1a  (Q,CLK,D);
output  Q;
input  CLK,D;
wire[0:0] temp0;
	DFFX2 (Q,temp0,CLK,D);
endfunction

function mcgen_fd1b  (Q,CLK,D);
output  Q;
input  CLK,D;
error("mcgen_fd1b is not available\n");
endfunction

function mcgen_fd1c  (QN,CLK,D);
output  QN;
input  CLK,D;
	wire [width(QN)-1:0] QOUT_xxx;
	wire CLOCK_xxx=sreg(CLK,0);
	wire [width(QN)-1:0] DATA_xxx=~D;
	QOUT_xxx=mcgen_fd1a(CLOCK_xxx,DATA_xxx);
	QN=QOUT_xxx;
endfunction

function mcgen_fd2a  (Q,CLK,CLR,D);
output  Q;
input  CLK,CLR,D;
wire[0:0] temp0;
	DFFARX2 (Q,temp0,CLK,D,CLR);
endfunction

function mcgen_fd3a  (Q,CLK,D,PRE);
output  Q;
input  CLK,D,PRE;
wire[0:0] temp0;
	DFFASX2 (Q,temp0,CLK,D,PRE);
endfunction

function mcgen_fd4a  (Q,CLK,CLR,D,PRE);
output  Q;
input  CLK,CLR,D,PRE;
wire[0:0] temp0;
	DFFASRX2 (Q,temp0,CLK,D,CLR,PRE);
endfunction

function mcgen_fd4b  (Q,CLK,CLR,D,PRE);
output  Q;
input  CLK,CLR,D,PRE;
	DFFNASRQX2 (Q,CLK,D,CLR,PRE);
endfunction

function mcgen_fd6a  (Q,QN,CLK,D);
output [0:0] Q,QN;
input [0:0] CLK,D;
	DFFX2 (Q,QN,CLK,D);
endfunction

function mcgen_fd7a  (Q,QN,CLK,CLR,D);
output [0:0] Q,QN;
input [0:0] CLK,CLR,D;
	DFFARX2 (Q,QN,CLK,D,CLR);
endfunction

function mcgen_fd8a  (Q,QN,CLK,D,PRE);
output [0:0] Q,QN;
input [0:0] CLK,D,PRE;
	DFFASX2 (Q,QN,CLK,D,PRE);
endfunction

function mcgen_fd9a  (Q,QN,CLK,CLR,D,PRE);
output [0:0] Q,QN;
input [0:0] CLK,CLR,D,PRE;
	DFFASRX2 (Q,QN,CLK,D,CLR,PRE);
endfunction

function mcgen_fdah2a  (Q,CLK,CLR,D);
output  Q;
input  CLK,CLR,D;
	wire [width(Q)-1:0] QOUT_xxx;
	wire CLOCK_xxx=sreg(CLK,0);
	wire [width(Q)-1:0] DATA_xxx=D;
	QOUT_xxx=mcgen_fd1a(CLOCK_xxx,DATA_xxx);
	CLEAR_xxx=CLR;
	Q=QOUT_xxx;
endfunction

function mcgen_fdah3a  (Q,CLK,D,PRE);
output  Q;
input  CLK,D,PRE;
	wire [width(Q)-1:0] QOUT_xxx;
	wire CLOCK_xxx=sreg(CLK,0);
	wire [width(Q)-1:0] DATA_xxx=D;
	QOUT_xxx=mcgen_fd1a(CLOCK_xxx,DATA_xxx);
	PRESET_xxx=PRE;
	Q=QOUT_xxx;
endfunction

function mcgen_fdah4a  (Q,CLK,CLR,D,PRE);
output  Q;
input  CLK,CLR,D,PRE;
	wire [width(Q)-1:0] QOUT_xxx;
	wire CLOCK_xxx=sreg(CLK,0);
	wire [width(Q)-1:0] DATA_xxx=D;
	QOUT_xxx=mcgen_fd1a(CLOCK_xxx,DATA_xxx);
	CLEAR_xxx=CLR;
	PRESET_xxx=PRE;
	Q=QOUT_xxx;
endfunction

function mcgen_fde1a  (Q,CLK,D,E);
output  Q;
input  CLK,D,E;
	mc_mcgen_fde1a1 (Q,CLK,D,E);
endfunction

function mcgen_fde1c  (Q,CLK,D,E);
output  Q;
input  CLK,D,E;
	wire [width(Q)-1:0] QOUT_xxx;
	wire CLOCK_xxx=sreg(CLK,0);
	wire [width(Q)-1:0] DATA_xxx=~(~(E?D:QOUT_xxx));
	QOUT_xxx=mcgen_fd1a(CLOCK_xxx,DATA_xxx);
	Q=~(~(~QOUT_xxx));
endfunction

function mcgen_fde2a  (Q,CLK,CLR,D,E);
output  Q;
input  CLK,CLR,D,E;
	mc_mcgen_fde2a1 (Q,CLK,CLR,D,E);
endfunction

function mcgen_fde3a  (Q,CLK,D,E,PRE);
output  Q;
input  CLK,D,E,PRE;
	mc_mcgen_fde3a1 (Q,CLK,D,E,PRE);
endfunction

function mcgen_fde4a  (Q,CLK,CLR,D,E,PRE);
output  Q;
input  CLK,CLR,D,E,PRE;
	mc_mcgen_fde4a1 (Q,CLK,CLR,D,E,PRE);
endfunction

function mcgen_fdeah2a  (Q,CLK,CLR,D,E);
output  Q;
input  CLK,CLR,D,E;
	wire [width(Q)-1:0] QOUT_xxx;
	wire CLOCK_xxx=sreg(CLK,0);
	wire [width(Q)-1:0] DATA_xxx=E?D:QOUT_xxx;
	QOUT_xxx=mcgen_fd1a(CLOCK_xxx,DATA_xxx);
	CLEAR_xxx=CLR;
	Q=QOUT_xxx;
endfunction

function mcgen_fdeah3a  (Q,CLK,D,E,PRE);
output  Q;
input  CLK,D,E,PRE;
	wire [width(Q)-1:0] QOUT_xxx;
	wire CLOCK_xxx=sreg(CLK,0);
	wire [width(Q)-1:0] DATA_xxx=E?D:QOUT_xxx;
	QOUT_xxx=mcgen_fd1a(CLOCK_xxx,DATA_xxx);
	PRESET_xxx=PRE;
	Q=QOUT_xxx;
endfunction

function mcgen_fdeah4a  (Q,CLK,CLR,D,E,PRE);
output  Q;
input  CLK,CLR,D,E,PRE;
	wire [width(Q)-1:0] QOUT_xxx;
	wire CLOCK_xxx=sreg(CLK,0);
	wire [width(Q)-1:0] DATA_xxx=E?D:QOUT_xxx;
	QOUT_xxx=mcgen_fd1a(CLOCK_xxx,DATA_xxx);
	CLEAR_xxx=CLR;
	PRESET_xxx=PRE;
	Q=QOUT_xxx;
endfunction

function mcgen_fdei1a  (Q,CLK,D,E);
output  Q;
input  CLK,D,E;
	mc_mcgen_fdei1a1 (Q,CLK,D,E);
endfunction

function mcgen_fdei2a  (Q,CLK,CLR,D,E);
output  Q;
input  CLK,CLR,D,E;
	mc_mcgen_fdei2a1 (Q,CLK,CLR,D,E);
endfunction

function mcgen_fdei3a  (Q,CLK,D,E,PRE);
output  Q;
input  CLK,D,E,PRE;
	mc_mcgen_fdei3a1 (Q,CLK,D,E,PRE);
endfunction

function mcgen_fdei4a  (Q,CLK,CLR,D,E,PRE);
output  Q;
input  CLK,CLR,D,E,PRE;
	mc_mcgen_fdei4a1 (Q,CLK,CLR,D,E,PRE);
endfunction

function mcgen_fdeiah2a  (Q,CLK,CLR,D,E);
output  Q;
input  CLK,CLR,D,E;
	wire [width(Q)-1:0] QOUT_xxx;
	wire CLOCK_xxx=sreg(CLK,0);
	wire [width(Q)-1:0] DATA_xxx=~E?D:QOUT_xxx;
	QOUT_xxx=mcgen_fd1a(CLOCK_xxx,DATA_xxx);
	CLEAR_xxx=CLR;
	Q=QOUT_xxx;
endfunction

function mcgen_fdeiah3a  (Q,CLK,D,E,PRE);
output  Q;
input  CLK,D,E,PRE;
	wire [width(Q)-1:0] QOUT_xxx;
	wire CLOCK_xxx=sreg(CLK,0);
	wire [width(Q)-1:0] DATA_xxx=~E?D:QOUT_xxx;
	QOUT_xxx=mcgen_fd1a(CLOCK_xxx,DATA_xxx);
	PRESET_xxx=PRE;
	Q=QOUT_xxx;
endfunction

function mcgen_fdeiah4a  (Q,CLK,CLR,D,E,PRE);
output  Q;
input  CLK,CLR,D,E,PRE;
	wire [width(Q)-1:0] QOUT_xxx;
	wire CLOCK_xxx=sreg(CLK,0);
	wire [width(Q)-1:0] DATA_xxx=~E?D:QOUT_xxx;
	QOUT_xxx=mcgen_fd1a(CLOCK_xxx,DATA_xxx);
	CLEAR_xxx=CLR;
	PRESET_xxx=PRE;
	Q=QOUT_xxx;
endfunction

function mcgen_fdem1c  (Q,CLK,D,E,T,TI);
output  Q;
input  CLK,D,E,T,TI;
	wire [width(Q)-1:0] QOUT_xxx;
	wire [width(Q)-1:0] DATA_xxx=~(~(T?TI:(E? D : QOUT_xxx)));
	wire CLOCK_xxx=sreg(CLK,0);
	QOUT_xxx=mcgen_fd1a(CLOCK_xxx,DATA_xxx);
	Q=~(~(~QOUT_xxx));
endfunction

function mcgen_fdm1a  (Q,CLK,D0,D1,S);
output  Q;
input  CLK,D0,D1,S;
wire[0:0] temp0;
	SDFFX2 (Q,temp0,CLK,D0,S,D1);
endfunction

function mcgen_fdm1b  (Q,CLK,D0,D1,S);
output  Q;
input  CLK,D0,D1,S;
error("mcgen_fdm1b is not available\n");
endfunction

function mcgen_fdm1c  (QN,CLK,D0,D1,S);
output  QN;
input  CLK,D0,D1,S;
	wire [width(QN)-1:0] QOUT_xxx;
	wire [width(QN)-1:0] DATA_xxx=~(S?D1:D0);
	wire CLOCK_xxx=sreg(CLK,0);
	QOUT_xxx=mcgen_fd1a(CLOCK_xxx,DATA_xxx);
	QN=QOUT_xxx;
endfunction

function mcgen_fdm1e  (Q,CLK,D0,D1,S);
output  Q;
input  CLK,D0,D1,S;
error("mcgen_fdm1e is not available\n");
endfunction

function mcgen_fdm1i  (Q,CLK,D0,D1,S);
output  Q;
input  CLK,D0,D1,S;
error("mcgen_fdm1i is not available\n");
endfunction

function mcgen_fdm2a  (Q,CLK,CLR,D0,D1,S);
output  Q;
input  CLK,CLR,D0,D1,S;
wire[0:0] temp0;
	SDFFARX2 (Q,temp0,CLK,D0,CLR,S,D1);
endfunction

function mcgen_fdm3a  (Q,CLK,D0,D1,PRE,S);
output  Q;
input  CLK,D0,D1,PRE,S;
wire[0:0] temp0;
	SDFFASX2 (Q,temp0,CLK,D0,S,PRE,D1);
endfunction

function mcgen_fdm4a  (Q,CLK,CLR,D0,D1,PRE,S);
output  Q;
input  CLK,CLR,D0,D1,PRE,S;
wire[0:0] temp0;
	SDFFASRX2 (Q,temp0,CLK,D0,CLR,S,PRE,D1);
endfunction

function mcgen_fdm4b  (Q,CLK,CLR,D0,D1,PRE,S);
output  Q;
input  CLK,CLR,D0,D1,PRE,S;
error("mcgen_fdm4b is not available\n");
endfunction

function mcgen_fdm5a  (Q,CLK,D0,D1,D2,S0,S1);
output  Q;
input  CLK,D0,D1,D2,S0,S1;
error("mcgen_fdm5a is not available\n");
endfunction

function mcgen_fdm7a  (Q,QN,CLK,CLR,D0,D1,S);
output [0:0] Q,QN;
input [0:0] CLK,CLR,D0,D1,S;
	SDFFARX2 (Q,QN,CLK,D0,CLR,S,D1);
endfunction

function mcgen_fdmah2a  (Q,CLK,CLR,D0,D1,S);
output  Q;
input  CLK,CLR,D0,D1,S;
	wire [width(Q)-1:0] QOUT_xxx;
	wire [width(Q)-1:0] DATA_xxx=S?D1:D0;
	wire CLOCK_xxx=sreg(CLK,0);
	QOUT_xxx=mcgen_fd1a(CLOCK_xxx,DATA_xxx);
	CLEAR_xxx=CLR;
	Q=QOUT_xxx;
endfunction

function mcgen_fdmah3a  (Q,CLK,D0,D1,PRE,S);
output  Q;
input  CLK,D0,D1,PRE,S;
	wire [width(Q)-1:0] QOUT_xxx;
	wire [width(Q)-1:0] DATA_xxx=S?D1:D0;
	wire CLOCK_xxx=sreg(CLK,0);
	QOUT_xxx=mcgen_fd1a(CLOCK_xxx,DATA_xxx);
	PRESET_xxx=PRE;
	Q=QOUT_xxx;
endfunction

function mcgen_fdmah4a  (Q,CLK,CLR,D0,D1,PRE,S);
output  Q;
input  CLK,CLR,D0,D1,PRE,S;
	wire [width(Q)-1:0] QOUT_xxx;
	wire [width(Q)-1:0] DATA_xxx=S?D1:D0;
	wire CLOCK_xxx=sreg(CLK,0);
	QOUT_xxx=mcgen_fd1a(CLOCK_xxx,DATA_xxx);
	CLEAR_xxx=CLR;
	PRESET_xxx=PRE;
	Q=QOUT_xxx;
endfunction

function mcgen_fdme1a  (Q,CLK,D,E,T,TI);
output  Q;
input  CLK,D,E,T,TI;
	wire [width(Q)-1:0] QOUT_xxx;
	wire [width(Q)-1:0] DATA_xxx=T?TI:(E? D : QOUT_xxx);
	wire CLOCK_xxx=sreg(CLK,0);
	QOUT_xxx=mcgen_fd1a(CLOCK_xxx,DATA_xxx);
	Q=QOUT_xxx;
endfunction

function mcgen_fdme2a  (Q,CLK,CLR,D,E,T,TI);
output  Q;
input  CLK,CLR,D,E,T,TI;
	wire [width(Q)-1:0] QOUT_xxx;
	wire [width(Q)-1:0] DATA_xxx=T?TI:(E? D : QOUT_xxx);
	wire CLOCK_xxx=sreg(CLK,0);
	QOUT_xxx=mcgen_fd1a(CLOCK_xxx,DATA_xxx);
	CLEAR_xxx=~CLR;
	Q=QOUT_xxx;
endfunction

function mcgen_fdme3a  (Q,CLK,D,E,PRE,T,TI);
output  Q;
input  CLK,D,E,PRE,T,TI;
	wire [width(Q)-1:0] QOUT_xxx;
	wire [width(Q)-1:0] DATA_xxx=T?TI:(E? D : QOUT_xxx);
	wire CLOCK_xxx=sreg(CLK,0);
	QOUT_xxx=mcgen_fd1a(CLOCK_xxx,DATA_xxx);
	PRESET_xxx=~PRE;
	Q=QOUT_xxx;
endfunction

function mcgen_fdme4a  (Q,CLK,CLR,D,E,PRE,T,TI);
output  Q;
input  CLK,CLR,D,E,PRE,T,TI;
	wire [width(Q)-1:0] QOUT_xxx;
	wire [width(Q)-1:0] DATA_xxx=T?TI:(E? D : QOUT_xxx);
	wire CLOCK_xxx=sreg(CLK,0);
	QOUT_xxx=mcgen_fd1a(CLOCK_xxx,DATA_xxx);
	CLEAR_xxx=~CLR;
	PRESET_xxx=~PRE;
	Q=QOUT_xxx;
endfunction

function mcgen_fdmeah2a  (Q,CLK,CLR,D,E,T,TI);
output  Q;
input  CLK,CLR,D,E,T,TI;
	wire [width(Q)-1:0] QOUT_xxx;
	wire [width(Q)-1:0] DATA_xxx=T?TI:(E? D : QOUT_xxx);
	wire CLOCK_xxx=sreg(CLK,0);
	QOUT_xxx=mcgen_fd1a(CLOCK_xxx,DATA_xxx);
	CLEAR_xxx=CLR;
	Q=QOUT_xxx;
endfunction

function mcgen_fdmeah3a  (Q,CLK,D,E,PRE,T,TI);
output  Q;
input  CLK,D,E,PRE,T,TI;
	wire [width(Q)-1:0] QOUT_xxx;
	wire [width(Q)-1:0] DATA_xxx=T?TI:(E? D : QOUT_xxx);
	wire CLOCK_xxx=sreg(CLK,0);
	QOUT_xxx=mcgen_fd1a(CLOCK_xxx,DATA_xxx);
	PRESET_xxx=PRE;
	Q=QOUT_xxx;
endfunction

function mcgen_fdmeah4a  (Q,CLK,CLR,D,E,PRE,T,TI);
output  Q;
input  CLK,CLR,D,E,PRE,T,TI;
	wire [width(Q)-1:0] QOUT_xxx;
	wire [width(Q)-1:0] DATA_xxx=T?TI:(E? D : QOUT_xxx);
	wire CLOCK_xxx=sreg(CLK,0);
	QOUT_xxx=mcgen_fd1a(CLOCK_xxx,DATA_xxx);
	CLEAR_xxx=CLR;
	PRESET_xxx=PRE;
	Q=QOUT_xxx;
endfunction

function mcgen_fdmei1a  (Q,CLK,D,E,T,TI);
output  Q;
input  CLK,D,E,T,TI;
	wire [width(Q)-1:0] QOUT_xxx;
	wire [width(Q)-1:0] DATA_xxx=T?TI:(~E? D : QOUT_xxx);
	wire CLOCK_xxx=sreg(CLK,0);
	QOUT_xxx=mcgen_fd1a(CLOCK_xxx,DATA_xxx);
	Q=QOUT_xxx;
endfunction

function mcgen_fdmei2a  (Q,CLK,CLR,D,E,T,TI);
output  Q;
input  CLK,CLR,D,E,T,TI;
	wire [width(Q)-1:0] QOUT_xxx;
	wire [width(Q)-1:0] DATA_xxx=T?TI:(~E? D : QOUT_xxx);
	wire CLOCK_xxx=sreg(CLK,0);
	QOUT_xxx=mcgen_fd1a(CLOCK_xxx,DATA_xxx);
	CLEAR_xxx=~CLR;
	Q=QOUT_xxx;
endfunction

function mcgen_fdmei3a  (Q,CLK,D,E,PRE,T,TI);
output  Q;
input  CLK,D,E,PRE,T,TI;
	wire [width(Q)-1:0] QOUT_xxx;
	wire [width(Q)-1:0] DATA_xxx=T?TI:(~E? D : QOUT_xxx);
	wire CLOCK_xxx=sreg(CLK,0);
	QOUT_xxx=mcgen_fd1a(CLOCK_xxx,DATA_xxx);
	PRESET_xxx=~PRE;
	Q=QOUT_xxx;
endfunction

function mcgen_fdmei4a  (Q,CLK,CLR,D,E,PRE,T,TI);
output  Q;
input  CLK,CLR,D,E,PRE,T,TI;
	wire [width(Q)-1:0] QOUT_xxx;
	wire [width(Q)-1:0] DATA_xxx=T?TI:(~E? D : QOUT_xxx);
	wire CLOCK_xxx=sreg(CLK,0);
	QOUT_xxx=mcgen_fd1a(CLOCK_xxx,DATA_xxx);
	CLEAR_xxx=~CLR;
	PRESET_xxx=~PRE;
	Q=QOUT_xxx;
endfunction

function mcgen_fdmeiah2a  (Q,CLK,CLR,D,E,T,TI);
output  Q;
input  CLK,CLR,D,E,T,TI;
	wire [width(Q)-1:0] QOUT_xxx;
	wire [width(Q)-1:0] DATA_xxx=T?TI:(~E? D : QOUT_xxx);
	wire CLOCK_xxx=sreg(CLK,0);
	QOUT_xxx=mcgen_fd1a(CLOCK_xxx,DATA_xxx);
	CLEAR_xxx=CLR;
	Q=QOUT_xxx;
endfunction

function mcgen_fdmeiah3a  (Q,CLK,D,E,PRE,T,TI);
output  Q;
input  CLK,D,E,PRE,T,TI;
	wire [width(Q)-1:0] QOUT_xxx;
	wire [width(Q)-1:0] DATA_xxx=T?TI:(~E? D : QOUT_xxx);
	wire CLOCK_xxx=sreg(CLK,0);
	QOUT_xxx=mcgen_fd1a(CLOCK_xxx,DATA_xxx);
	PRESET_xxx=PRE;
	Q=QOUT_xxx;
endfunction

function mcgen_fdmeiah4a  (Q,CLK,CLR,D,E,PRE,T,TI);
output  Q;
input  CLK,CLR,D,E,PRE,T,TI;
	wire [width(Q)-1:0] QOUT_xxx;
	wire [width(Q)-1:0] DATA_xxx=T?TI:(~E? D : QOUT_xxx);
	wire CLOCK_xxx=sreg(CLK,0);
	QOUT_xxx=mcgen_fd1a(CLOCK_xxx,DATA_xxx);
	CLEAR_xxx=CLR;
	PRESET_xxx=PRE;
	Q=QOUT_xxx;
endfunction

function mcgen_fjk1a  (Q,CLKX,JX,KX);
output  Q;
input  CLKX,JX,KX;
error("mcgen_fjk1a is not available\n");
endfunction

function mcgen_gnd_generic  (Y);
output  Y;
	Y=0;
warning("mcgen_gnd_generic is not instantiated\n");
endfunction

function mcgen_ha1a  (CO,S,A,B);
output [0:0] CO,S;
input [0:0] A,B;
	HADDX2 (CO,S,A,B);
endfunction

function mcgen_ha1b  (CO,S,A,B);
output [0:0] CO,S;
input [0:0] A,B;
	mc_mcgen_ha1b1 (CO,S,A,B);
endfunction

function mcgen_ha2a  (CO,S,A,B);
output [0:0] CO,S;
input [0:0] A,B;
	mc_mcgen_ha2a1 (CO,S,A,B);
endfunction

function mcgen_ha3a  (CO,S,A,B);
output [0:0] CO,S;
input [0:0] A,B;
	mc_mcgen_ha3a1 (CO,S,A,B);
endfunction

function mcgen_ha4a  (CO,S,A,B);
output [0:0] CO,S;
input [0:0] A,B;
	mc_mcgen_ha4a1 (CO,S,A,B);
endfunction

function mcgen_hacs1b  (CO,S,A,B,CSIN);
output [0:0] CO,S;
input [0:0] A,B,CSIN;
	mc_mcgen_hacs1b1_1 (CO,S,A,B,CSIN);
endfunction

function mcgen_hacs2a  (CO,S,A,B,CSIN);
output [0:0] CO,S;
input [0:0] A,B,CSIN;
	mc_mcgen_hacs2a1_1 (CO,S,A,B,CSIN);
endfunction

function mcgen_hacs3a  (CO,S,A,CSIN);
output [0:0] CO,S;
input [0:0] A,CSIN;
	mc_mcgen_hacs3a1 (CO,S,A,CSIN);
endfunction

function mcgen_inv1a  (Y,A);
output  Y;
input  A;
	INVX32 (Y,A);
endfunction

function mcgen_ld1a  (Q,D,G);
output  Q;
input  D,G;
wire[0:0] temp0;
	LATCHX2 (Q,temp0,G,D);
endfunction

function mcgen_ld1b  (Q,D,G);
output  Q;
input  D,G;
	wire [width(Q)-1:0] QOUT_xxx;
	wire GATE_xxx=sreg(~G,0);
	wire [width(Q)-1:0] DATA_xxx=D;
	QOUT_xxx=mcgen_ld1a(DATA_xxx,GATE_xxx);
	Q=QOUT_xxx;
endfunction

function mcgen_ld1c  (QN,D,G);
output  QN;
input  D,G;
	wire [width(QN)-1:0] QOUT_xxx;
	wire GATE_xxx=sreg(G,0);
	wire [width(QN)-1:0] DATA_xxx=~D;
	QOUT_xxx=mcgen_ld1a(DATA_xxx,GATE_xxx);
	QN=QOUT_xxx;
endfunction

function mcgen_ld2a  (Q,CLR,D,G);
output  Q;
input  CLR,D,G;
error("mcgen_ld2a is not available\n");
endfunction

function mcgen_ld2b  (Q,CLR,D,G);
output  Q;
input  CLR,D,G;
error("mcgen_ld2b is not available\n");
endfunction

function mcgen_ld4a  (Q,CLR,D,G,PRE);
output  Q;
input  CLR,D,G,PRE;
	LASRQX2 (Q,G,D,CLR,PRE);
endfunction

function mcgen_ldm1a  (Q,D0,D1,G,S);
output  Q;
input  D0,D1,G,S;
error("mcgen_ldm1a is not available\n");
endfunction

function mcgen_ldm1b  (Q,D0,D1,G,S);
output  Q;
input  D0,D1,G,S;
error("mcgen_ldm1b is not available\n");
endfunction

function mcgen_ldm1c  (QN,D0,D1,G,S);
output  QN;
input  D0,D1,G,S;
error("mcgen_ldm1c is not available\n");
endfunction

function mcgen_ldm2a  (Q,CLR,D0,D1,G,S);
output  Q;
input  CLR,D0,D1,G,S;
error("mcgen_ldm2a is not available\n");
endfunction

function mcgen_mule2a  (M,S,Z,A,B,C);
output [0:0] M,S,Z;
input [0:0] A,B,C;
	mc_mcgen_mule2a1 (M,S,Z,A,B,C);
endfunction

function mcgen_mulpa1b  (P,M,S,X0,X1,Z);
output  P;
input  M,S,X0,X1,Z;
	mc_mcgen_mulpa1b1 (P,M,S,X0,X1,Z);
endfunction

function mcgen_mulpa2b  (P,M,S,X0,X1,Z);
output  P;
input  M,S,X0,X1,Z;
	mc_mcgen_mulpa2b1 (P,M,S,X0,X1,Z);
endfunction

function mcgen_mulpa3b  (P,M,S,X0,X1,Z);
output  P;
input  M,S,X0,X1,Z;
	mc_mcgen_mulpa1b1 (P,M,S,X0,X1,Z);
endfunction

function mcgen_mx2a  (Y,D0,D1,S);
output  Y;
input  D0,D1,S;
	MUX21X2 (Y,D0,D1,S);
endfunction

function mcgen_mx2d  (Y,D0,D1,S);
output  Y;
input  D0,D1,S;
	mc_mcgen_mx2d1 (Y,D0,D1,S);
endfunction

function mcgen_mx3a  (Y,D0,D1,D2,S0,S1);
output  Y;
input  D0,D1,D2,S0,S1;
	mc_mcgen_mx3a1 (Y,D0,D1,D2,S0,S1);
endfunction

function mcgen_mx3d  (Y,D0,D1,D2,S0,S1);
output  Y;
input  D0,D1,D2,S0,S1;
	mc_mcgen_mx3d1 (Y,D0,D1,D2,S0,S1);
endfunction

function mcgen_mx4a  (Y,D0,D1,D2,D3,S0,S1);
output  Y;
input  D0,D1,D2,D3,S0,S1;
	MUX41X2 (Y,D0,D1,D2,D3,S1,S0);
endfunction

function mcgen_mx4d  (Y,D0,D1,D2,D3,S0,S1);
output  Y;
input  D0,D1,D2,D3,S0,S1;
	mc_mcgen_mx4d1 (Y,D0,D1,D2,D3,S0,S1);
endfunction

function mcgen_mx4e  (Y,D0,D1,D2,D3,S0,S1);
output  Y;
input  D0,D1,D2,D3,S0,S1;
	mc_mcgen_mx4d1 (Y,D0,D1,D2,D3,S0,S1);
endfunction

function mcgen_nand2a  (Y,A,B);
output  Y;
input  A,B;
	NAND2X4 (Y,A,B);
endfunction

function mcgen_nand2b  (Y,A,B);
output  Y;
input  A,B;
	mc_mcgen_or2d1 (Y,A,B);
endfunction

function mcgen_nand2c  (Y,A,B);
output  Y;
input  A,B;
	ISOLORX4 (Y,B,A);
endfunction

function mcgen_nand3a  (Y,A,B,C);
output  Y;
input  A,B,C;
	NAND3X4 (Y,A,B,C);
endfunction

function mcgen_nand3b  (Y,A,B,C);
output  Y;
input  A,B,C;
	Y=~(~A&B&C);
warning("mcgen_nand3b is not instantiated\n");
endfunction

function mcgen_nand3c  (Y,A,B,C);
output  Y;
input  A,B,C;
	Y=~(~A&~B&C);
warning("mcgen_nand3c is not instantiated\n");
endfunction

function mcgen_nand3d  (Y,A,B,C);
output  Y;
input  A,B,C;
	OR3X4 (Y,A,B,C);
endfunction

function mcgen_nand4a  (Y,A,B,C,D);
output  Y;
input  A,B,C,D;
	NAND4X1 (Y,A,B,C,D);
endfunction

function mcgen_nand4b  (Y,A,B,C,D);
output  Y;
input  A,B,C,D;
	Y=~(~A&B&C&D);
warning("mcgen_nand4b is not instantiated\n");
endfunction

function mcgen_nand4c  (Y,A,B,C,D);
output  Y;
input  A,B,C,D;
	Y=~(~A&~B&C&D);
warning("mcgen_nand4c is not instantiated\n");
endfunction

function mcgen_nand4d  (Y,A,B,C,D);
output  Y;
input  A,B,C,D;
	Y=~(~A&~B&~C&D);
warning("mcgen_nand4d is not instantiated\n");
endfunction

function mcgen_nand4e  (Y,A,B,C,D);
output  Y;
input  A,B,C,D;
	OR4X4 (Y,A,B,C,D);
endfunction

function mcgen_nand5a  (Y,A,B,C,D,E);
output  Y;
input  A,B,C,D,E;
	Y=~(A&B&C&D&E);
warning("mcgen_nand5a is not instantiated\n");
endfunction

function mcgen_nand5b  (Y,A,B,C,D,E);
output  Y;
input  A,B,C,D,E;
	Y=~(~A&B&C&D&E);
warning("mcgen_nand5b is not instantiated\n");
endfunction

function mcgen_nand5c  (Y,A,B,C,D,E);
output  Y;
input  A,B,C,D,E;
	Y=~(~A&~B&C&D&E);
warning("mcgen_nand5c is not instantiated\n");
endfunction

function mcgen_nand5d  (Y,A,B,C,D,E);
output  Y;
input  A,B,C,D,E;
	Y=~(~A&~B&~C&D&E);
warning("mcgen_nand5d is not instantiated\n");
endfunction

function mcgen_nand5e  (Y,A,B,C,D,E);
output  Y;
input  A,B,C,D,E;
	Y=~(~A&~B&~C&~D&E);
warning("mcgen_nand5e is not instantiated\n");
endfunction

function mcgen_nand5f  (Y,A,B,C,D,E);
output  Y;
input  A,B,C,D,E;
	Y=~(~A&~B&~C&~D&~E);
warning("mcgen_nand5f is not instantiated\n");
endfunction

function mcgen_nand6a  (Y,A,B,C,D,E,F);
output  Y;
input  A,B,C,D,E,F;
	Y=~(A&B&C&D&E&F);
warning("mcgen_nand6a is not instantiated\n");
endfunction

function mcgen_nand7a  ();
warning("mcgen_nand7a is not instantiated\n");
endfunction

function mcgen_nand8a  (Y,A,B,C,D,E,F,G,H);
output  Y;
input  A,B,C,D,E,F,G,H;
	Y=~(A&B&C&D&E&F&G&H);
warning("mcgen_nand8a is not instantiated\n");
endfunction

function mcgen_nor2a  (Y,A,B);
output  Y;
input  A,B;
	NOR2X4 (Y,A,B);
endfunction

function mcgen_nor2b  (Y,A,B);
output  Y;
input  A,B;
	ISOLANDX8 (Y,A,B);
endfunction

function mcgen_nor2c  (Y,A,B);
output  Y;
input  A,B;
	AND2X4 (Y,A,B);
endfunction

function mcgen_nor3a  (Y,A,B,C);
output  Y;
input  A,B,C;
	NOR3X4 (Y,A,B,C);
endfunction

function mcgen_nor3b  (Y,A,B,C);
output  Y;
input  A,B,C;
	Y=~(~A|B|C);
warning("mcgen_nor3b is not instantiated\n");
endfunction

function mcgen_nor3c  (Y,A,B,C);
output  Y;
input  A,B,C;
	Y=~(~A|~B|C);
warning("mcgen_nor3c is not instantiated\n");
endfunction

function mcgen_nor3d  (Y,A,B,C);
output  Y;
input  A,B,C;
	AND3X4 (Y,A,B,C);
endfunction

function mcgen_nor4a  (Y,A,B,C,D);
output  Y;
input  A,B,C,D;
	NOR4X1 (Y,A,B,C,D);
endfunction

function mcgen_nor4b  (Y,A,B,C,D);
output  Y;
input  A,B,C,D;
	Y=~(~A|B|C|D);
warning("mcgen_nor4b is not instantiated\n");
endfunction

function mcgen_nor4c  (Y,A,B,C,D);
output  Y;
input  A,B,C,D;
	Y=~(~A|~B|C|D);
warning("mcgen_nor4c is not instantiated\n");
endfunction

function mcgen_nor4d  (Y,A,B,C,D);
output  Y;
input  A,B,C,D;
	Y=~(~A|~B|~C|D);
warning("mcgen_nor4d is not instantiated\n");
endfunction

function mcgen_nor4e  (Y,A,B,C,D);
output  Y;
input  A,B,C,D;
	AND4X4 (Y,A,B,C,D);
endfunction

function mcgen_nor5a  (Y,A,B,C,D,E);
output  Y;
input  A,B,C,D,E;
	Y=~(A|B|C|D|E);
warning("mcgen_nor5a is not instantiated\n");
endfunction

function mcgen_nor5b  (Y,A,B,C,D,E);
output  Y;
input  A,B,C,D,E;
	Y=~(~A|B|C|D|E);
warning("mcgen_nor5b is not instantiated\n");
endfunction

function mcgen_nor5c  (Y,A,B,C,D,E);
output  Y;
input  A,B,C,D,E;
	Y=~(~A|~B|C|D|E);
warning("mcgen_nor5c is not instantiated\n");
endfunction

function mcgen_nor5d  (Y,A,B,C,D,E);
output  Y;
input  A,B,C,D,E;
	Y=~(~A|~B|~C|D|E);
warning("mcgen_nor5d is not instantiated\n");
endfunction

function mcgen_nor5e  (Y,A,B,C,D,E);
output  Y;
input  A,B,C,D,E;
	Y=~(~A|~B|~C|~D|E);
warning("mcgen_nor5e is not instantiated\n");
endfunction

function mcgen_nor5f  (Y,A,B,C,D,E);
output  Y;
input  A,B,C,D,E;
	Y=~(~A|~B|~C|~D|~E);
warning("mcgen_nor5f is not instantiated\n");
endfunction

function mcgen_nor6a  (Y,A,B,C,D,E,F);
output  Y;
input  A,B,C,D,E,F;
	Y=~(A|B|C|D|E|F);
warning("mcgen_nor6a is not instantiated\n");
endfunction

function mcgen_nor7a  ();
warning("mcgen_nor7a is not instantiated\n");
endfunction

function mcgen_nor8a  (Y,A,B,C,D,E,F,G,H);
output  Y;
input  A,B,C,D,E,F,G,H;
	Y=~(A|B|C|D|E|F|G|H);
warning("mcgen_nor8a is not instantiated\n");
endfunction

function mcgen_oa1a  (Y,A,B,C);
output  Y;
input  A,B,C;
	OA21X2 (Y,A,B,C);
endfunction

function mcgen_oa1b  (Y,A,B,C);
output  Y;
input  A,B,C;
	Y=(~A|B)&C;
warning("mcgen_oa1b is not instantiated\n");
endfunction

function mcgen_oa1c  (Y,A,B,C);
output  Y;
input  A,B,C;
	Y=(~A|~B)&C;
warning("mcgen_oa1c is not instantiated\n");
endfunction

function mcgen_oa1d  (Y,A,B,C);
output  Y;
input  A,B,C;
	Y=(A|B)&~C;
warning("mcgen_oa1d is not instantiated\n");
endfunction

function mcgen_oa1e  (Y,A,B,C);
output  Y;
input  A,B,C;
	Y=(~A|B)&~C;
warning("mcgen_oa1e is not instantiated\n");
endfunction

function mcgen_oa1f  (Y,A,B,C);
output  Y;
input  A,B,C;
	AOI21X2 (Y,A,B,C);
endfunction

function mcgen_oa2a  (Y,A,B,C,D);
output  Y;
input  A,B,C,D;
	Y=(A|B)&C&D;
warning("mcgen_oa2a is not instantiated\n");
endfunction

function mcgen_oa2b  (Y,A,B,C,D);
output  Y;
input  A,B,C,D;
	Y=(~A|B)&C&D;
warning("mcgen_oa2b is not instantiated\n");
endfunction

function mcgen_oa2c  (Y,A,B,C,D);
output  Y;
input  A,B,C,D;
	Y=(~A|~B)&C&D;
warning("mcgen_oa2c is not instantiated\n");
endfunction

function mcgen_oa2d  (Y,A,B,C,D);
output  Y;
input  A,B,C,D;
	Y=(A|B)&~C&D;
warning("mcgen_oa2d is not instantiated\n");
endfunction

function mcgen_oa2e  (Y,A,B,C,D);
output  Y;
input  A,B,C,D;
	Y=(~A|B)&~C&D;
warning("mcgen_oa2e is not instantiated\n");
endfunction

function mcgen_oa2f  (Y,A,B,C,D);
output  Y;
input  A,B,C,D;
	Y=(~A|~B)&~C&D;
warning("mcgen_oa2f is not instantiated\n");
endfunction

function mcgen_oa2g  (Y,A,B,C,D);
output  Y;
input  A,B,C,D;
	Y=(A|B)&~C&~D;
warning("mcgen_oa2g is not instantiated\n");
endfunction

function mcgen_oa2h  (Y,A,B,C,D);
output  Y;
input  A,B,C,D;
	Y=(~A|B)&~C&~D;
warning("mcgen_oa2h is not instantiated\n");
endfunction

function mcgen_oa2i  (Y,A,B,C,D);
output  Y;
input  A,B,C,D;
	Y=(~A|~B)&~C&~D;
warning("mcgen_oa2i is not instantiated\n");
endfunction

function mcgen_oa3a  (Y,A,B,C,D);
output  Y;
input  A,B,C,D;
	Y=(A|B|C)&D;
warning("mcgen_oa3a is not instantiated\n");
endfunction

function mcgen_oa3b  (Y,A,B,C,D);
output  Y;
input  A,B,C,D;
	Y=(~A|B|C)&D;
warning("mcgen_oa3b is not instantiated\n");
endfunction

function mcgen_oa3c  (Y,A,B,C,D);
output  Y;
input  A,B,C,D;
	Y=(~A|~B|C)&D;
warning("mcgen_oa3c is not instantiated\n");
endfunction

function mcgen_oa3d  (Y,A,B,C,D);
output  Y;
input  A,B,C,D;
	Y=(~A|~B|~C)&D;
warning("mcgen_oa3d is not instantiated\n");
endfunction

function mcgen_oa3e  (Y,A,B,C,D);
output  Y;
input  A,B,C,D;
	Y=(A|B|C)&~D;
warning("mcgen_oa3e is not instantiated\n");
endfunction

function mcgen_oa3f  (Y,A,B,C,D);
output  Y;
input  A,B,C,D;
	Y=(~A|B|C)&~D;
warning("mcgen_oa3f is not instantiated\n");
endfunction

function mcgen_oa3g  (Y,A,B,C,D);
output  Y;
input  A,B,C,D;
	Y=(~A|~B|C)&~D;
warning("mcgen_oa3g is not instantiated\n");
endfunction

function mcgen_oa3h  (Y,A,B,C,D);
output  Y;
input  A,B,C,D;
	Y=(~A|~B|~C)&~D;
warning("mcgen_oa3h is not instantiated\n");
endfunction

function mcgen_oa4a  (Y,A,B,C,D);
output  Y;
input  A,B,C,D;
	OA22X2 (Y,A,B,C,D);
endfunction

function mcgen_oa4b  (Y,A,B,C,D);
output  Y;
input  A,B,C,D;
	Y=(~A|B)&(C|D);
warning("mcgen_oa4b is not instantiated\n");
endfunction

function mcgen_oa4c  (Y,A,B,C,D);
output  Y;
input  A,B,C,D;
	Y=(~A|~B)&(C|D);
warning("mcgen_oa4c is not instantiated\n");
endfunction

function mcgen_oa4d  (Y,A,B,C,D);
output  Y;
input  A,B,C,D;
	Y=(~A|B)&(~C|D);
warning("mcgen_oa4d is not instantiated\n");
endfunction

function mcgen_oa4e  (Y,A,B,C,D);
output  Y;
input  A,B,C,D;
	Y=(~A|B)&(~C|~D);
warning("mcgen_oa4e is not instantiated\n");
endfunction

function mcgen_oa4f  (Y,A,B,C,D);
output  Y;
input  A,B,C,D;
	AOI22X2 (Y,A,B,C,D);
endfunction

function mcgen_oa5a  (Y,A,B,C,D,E);
output  Y;
input  A,B,C,D,E;
	Y=(A|B|C) & (D|E);
warning("mcgen_oa5a is not instantiated\n");
endfunction

function mcgen_oa5b  (Y,A,B,C,D,E);
output  Y;
input  A,B,C,D,E;
	Y=(~A|B|C) & (D|E);
warning("mcgen_oa5b is not instantiated\n");
endfunction

function mcgen_oa7a  (Y,A,B,C,D,E,F);
output  Y;
input  A,B,C,D,E,F;
	OA222X2 (Y,A,B,C,D,E,F);
endfunction

function mcgen_oa7g  (Y,A,B,C,D,E,F);
output  Y;
input  A,B,C,D,E,F;
	AOI222X2 (Y,A,B,C,D,E,F);
endfunction

function mcgen_oa8a  (Y,A,B,C,D,E);
output  Y;
input  A,B,C,D,E;
	OA221X2 (Y,A,B,C,D,E);
endfunction

function mcgen_or2a  (Y,A,B);
output  Y;
input  A,B;
	ISOLORX4 (Y,B,A);
endfunction

function mcgen_or2b  (Y,A,B);
output  Y;
input  A,B;
	mc_mcgen_or2d1 (Y,B,A);
endfunction

function mcgen_or2c  (Y,A,B);
output  Y;
input  A,B;
	NAND2X4 (Y,A,B);
endfunction

function mcgen_or2d  (Y,A,B);
output  Y;
input  A,B;
	mc_mcgen_or2d1 (Y,A,B);
endfunction

function mcgen_or3a  (Y,A,B,C);
output  Y;
input  A,B,C;
	OR3X4 (Y,A,B,C);
endfunction

function mcgen_or3b  (Y,A,B,C);
output  Y;
input  A,B,C;
	Y=~A|B|C;
warning("mcgen_or3b is not instantiated\n");
endfunction

function mcgen_or3c  (Y,A,B,C);
output  Y;
input  A,B,C;
	Y=~A|~B|C;
warning("mcgen_or3c is not instantiated\n");
endfunction

function mcgen_or3d  (Y,A,B,C);
output  Y;
input  A,B,C;
	NAND3X4 (Y,A,B,C);
endfunction

function mcgen_or4a  (Y,A,B,C,D);
output  Y;
input  A,B,C,D;
	OR4X4 (Y,A,B,C,D);
endfunction

function mcgen_or4b  (Y,A,B,C,D);
output  Y;
input  A,B,C,D;
	Y=~A|B|C|D;
warning("mcgen_or4b is not instantiated\n");
endfunction

function mcgen_or4c  (Y,A,B,C,D);
output  Y;
input  A,B,C,D;
	Y=~A|~B|C|D;
warning("mcgen_or4c is not instantiated\n");
endfunction

function mcgen_or4d  (Y,A,B,C,D);
output  Y;
input  A,B,C,D;
	Y=~A|~B|~C|D;
warning("mcgen_or4d is not instantiated\n");
endfunction

function mcgen_or4e  (Y,A,B,C,D);
output  Y;
input  A,B,C,D;
	NAND4X1 (Y,A,B,C,D);
endfunction

function mcgen_or5a  (Y,A,B,C,D,E);
output  Y;
input  A,B,C,D,E;
	Y=A|B|C|D|E;
warning("mcgen_or5a is not instantiated\n");
endfunction

function mcgen_or5b  (Y,A,B,C,D,E);
output  Y;
input  A,B,C,D,E;
	Y=~A|B|C|D|E;
warning("mcgen_or5b is not instantiated\n");
endfunction

function mcgen_or5c  (Y,A,B,C,D,E);
output  Y;
input  A,B,C,D,E;
	Y=~A|~B|C|D|E;
warning("mcgen_or5c is not instantiated\n");
endfunction

function mcgen_or5d  (Y,A,B,C,D,E);
output  Y;
input  A,B,C,D,E;
	Y=~A|~B|~C|D|E;
warning("mcgen_or5d is not instantiated\n");
endfunction

function mcgen_or5e  (Y,A,B,C,D,E);
output  Y;
input  A,B,C,D,E;
	Y=~A|~B|~C|~D|E;
warning("mcgen_or5e is not instantiated\n");
endfunction

function mcgen_or5f  (Y,A,B,C,D,E);
output  Y;
input  A,B,C,D,E;
	Y=~A|~B|~C|~D|~E;
warning("mcgen_or5f is not instantiated\n");
endfunction

function mcgen_or6a  (Y,A,B,C,D,E,F);
output  Y;
input  A,B,C,D,E,F;
	Y=A|B|C|D|E|F;
warning("mcgen_or6a is not instantiated\n");
endfunction

function mcgen_or6g  (Y,A,B,C,D,E,F);
output  Y;
input  A,B,C,D,E,F;
	Y=~A|~B|~C|~D|~E|~F;
warning("mcgen_or6g is not instantiated\n");
endfunction

function mcgen_or7a  ();
warning("mcgen_or7a is not instantiated\n");
endfunction

function mcgen_or8a  ();
warning("mcgen_or8a is not instantiated\n");
endfunction

function mcgen_or8i  (Y,A,B,C,D,E,F,G,H);
output  Y;
input  A,B,C,D,E,F,G,H;
	Y=~A|~B|~C|~D|~E|~F|~G|~H;
warning("mcgen_or8i is not instantiated\n");
endfunction

function mcgen_tri1a  (Y,A,E);
output  Y;
input  A,E;
	TNBUFFX32 (Y,E,A);
endfunction

function mcgen_tri1b  (Y,A,E);
output  Y;
input  A,E;
	Y=~A%E;
warning("mcgen_tri1b is not instantiated\n");
endfunction

function mcgen_vdd_generic  (Y);
output  Y;
	Y=1;
warning("mcgen_vdd_generic is not instantiated\n");
endfunction

function mcgen_xa1a  (Y,A,B,C);
output  Y;
input  A,B,C;
	Y=(A ^ B)&C;
warning("mcgen_xa1a is not instantiated\n");
endfunction

function mcgen_xa1b  (Y,A,B,C);
output  Y;
input  A,B,C;
	Y=(~A ^ B)&C;
warning("mcgen_xa1b is not instantiated\n");
endfunction

function mcgen_xa1d  (Y,A,B,C);
output  Y;
input  A,B,C;
	Y=(~A ^ B)&~C;
warning("mcgen_xa1d is not instantiated\n");
endfunction

function mcgen_xnor2a  (Y,A,B);
output  Y;
input  A,B;
	XNOR2X2 (Y,A,B);
endfunction

function mcgen_xnor3a  (Y,A,B,C);
output  Y;
input  A,B,C;
	XNOR3X2 (Y,A,B,C);
endfunction

function mcgen_xnor4a  (Y,A,B,C,D);
output  Y;
input  A,B,C,D;
	mc_mcgen_xnor4a1 (Y,A,B,C,D);
endfunction

function mcgen_xor2a  (Y,A,B);
output  Y;
input  A,B;
	XOR2X2 (Y,A,B);
endfunction

function mcgen_xor2b  (Y,A,B);
output  Y;
input  A,B;
	XNOR2X2 (Y,A,B);
endfunction

function mcgen_xor3a  (Y,A,B,C);
output  Y;
input  A,B,C;
	XOR3X2 (Y,A,B,C);
endfunction

function mcgen_xor3b  (Y,A,B,C);
output  Y;
input  A,B,C;
	XNOR3X2 (Y,A,B,C);
endfunction

function mcgen_xor4a  (Y,A,B,C,D);
output  Y;
input  A,B,C,D;
	mc_mcgen_xor4a1 (Y,A,B,C,D);
endfunction

function ANTENNA CELL (INP);
input fb [0:0] INP;
endfunction

function AODFFNARX1 CELL (Q,QN,CLK,D,RSTB);
output [0:0] Q,QN;
input [0:0] CLK;
input fb [0:0] D,RSTB;
endfunction

function AODFFNARX2 CELL (Q,QN,CLK,D,RSTB);
output [0:0] Q,QN;
input [0:0] CLK;
input fb [0:0] D,RSTB;
endfunction

function AOI221X1 CELL (QN,IN1,IN2,IN3,IN4,IN5);
output  QN;
input  IN1,IN2,IN3,IN4,IN5;
endfunction

function AOI221X2 CELL (QN,IN1,IN2,IN3,IN4,IN5);
output  QN;
input  IN1,IN2,IN3,IN4,IN5;
endfunction

function BSLEX1 CELL (INOUT2,ENB,INOUT1);
output  INOUT2;
input fb  ENB;
input  INOUT1;
endfunction

function BSLEX2 CELL (INOUT2,ENB,INOUT1);
output  INOUT2;
input fb  ENB;
input  INOUT1;
endfunction

function BSLEX4 CELL (INOUT2,ENB,INOUT1);
output  INOUT2;
input fb  ENB;
input  INOUT1;
endfunction

function BUSKP CELL (INP);
input fb [0:0] INP;
endfunction

function CLOAD1 CELL (INP);
input fb [0:0] INP;
endfunction

function DCAP CELL ();
endfunction

function DEC24X1 CELL (Q0,Q1,Q2,Q3,IN1,IN2);
output [0:0] Q0,Q1,Q2,Q3;
input [0:0] IN1,IN2;
endfunction

function DEC24X2 CELL (Q0,Q1,Q2,Q3,IN1,IN2);
output [0:0] Q0,Q1,Q2,Q3;
input [0:0] IN1,IN2;
endfunction

function DFFNARX1 CELL (Q,QN,CLK,D,RSTB);
output [0:0] Q,QN;
input [0:0] CLK;
input fb [0:0] D,RSTB;
endfunction

function DFFNARX2 CELL (Q,QN,CLK,D,RSTB);
output [0:0] Q,QN;
input [0:0] CLK;
input fb [0:0] D,RSTB;
endfunction

function DFFNASRNX1 CELL (QN,CLK,D,RSTB,SETB);
output  QN;
input  CLK;
input fb  D,RSTB,SETB;
endfunction

function DFFNASRNX2 CELL (QN,CLK,D,RSTB,SETB);
output  QN;
input  CLK;
input fb  D,RSTB,SETB;
endfunction

function DFFNASRX1 CELL (Q,QN,CLK,D,RSTB,SETB);
output [0:0] Q,QN;
input [0:0] CLK;
input fb [0:0] D,RSTB,SETB;
endfunction

function DFFNASRX2 CELL (Q,QN,CLK,D,RSTB,SETB);
output [0:0] Q,QN;
input [0:0] CLK;
input fb [0:0] D,RSTB,SETB;
endfunction

function DFFNASX1 CELL (Q,QN,CLK,D,SETB);
output [0:0] Q,QN;
input [0:0] CLK;
input fb [0:0] D,SETB;
endfunction

function DFFNASX2 CELL (Q,QN,CLK,D,SETB);
output [0:0] Q,QN;
input [0:0] CLK;
input fb [0:0] D,SETB;
endfunction

function DFFNX1 CELL (Q,QN,CLK,D);
output [0:0] Q,QN;
input [0:0] CLK;
input fb [0:0] D;
endfunction

function DFFNX2 CELL (Q,QN,CLK,D);
output [0:0] Q,QN;
input [0:0] CLK;
input fb [0:0] D;
endfunction

function DFFSSRX1 CELL (Q,QN,CLK,D,RSTB,SETB);
output [0:0] Q,QN;
input [0:0] CLK;
input fb [0:0] D,RSTB,SETB;
endfunction

function DFFSSRX2 CELL (Q,QN,CLK,D,RSTB,SETB);
output [0:0] Q,QN;
input [0:0] CLK;
input fb [0:0] D,RSTB,SETB;
endfunction

function DHFILLHLH2 CELL ();
endfunction

function DHFILLHLHLS11 CELL ();
endfunction

function DHFILLLHL2 CELL ();
endfunction

function HEADX16 CELL (SLEEP);
input fb [0:0] SLEEP;
endfunction

function HEADX2 CELL (SLEEP);
input fb [0:0] SLEEP;
endfunction

function HEADX32 CELL (SLEEP);
input fb [0:0] SLEEP;
endfunction

function HEADX4 CELL (SLEEP);
input fb [0:0] SLEEP;
endfunction

function HEADX8 CELL (SLEEP);
input fb [0:0] SLEEP;
endfunction

function LARX1 CELL (Q,QN,CLK,D,RSTB);
output [0:0] Q,QN;
input [0:0] CLK,D;
input fb [0:0] RSTB;
endfunction

function LARX2 CELL (Q,QN,CLK,D,RSTB);
output [0:0] Q,QN;
input [0:0] CLK,D;
input fb [0:0] RSTB;
endfunction

function LASRNX1 CELL (QN,CLK,D,RSTB,SETB);
output  QN;
input  CLK,D;
input fb  RSTB,SETB;
endfunction

function LASRNX2 CELL (QN,CLK,D,RSTB,SETB);
output  QN;
input  CLK,D;
input fb  RSTB,SETB;
endfunction

function LASRX1 CELL (Q,QN,CLK,D,RSTB,SETB);
output [0:0] Q,QN;
input [0:0] CLK,D;
input fb [0:0] RSTB,SETB;
endfunction

function LASRX2 CELL (Q,QN,CLK,D,RSTB,SETB);
output [0:0] Q,QN;
input [0:0] CLK,D;
input fb [0:0] RSTB,SETB;
endfunction

function LASX1 CELL (Q,QN,CLK,D,SETB);
output [0:0] Q,QN;
input [0:0] CLK,D;
input fb [0:0] SETB;
endfunction

function LASX2 CELL (Q,QN,CLK,D,SETB);
output [0:0] Q,QN;
input [0:0] CLK,D;
input fb [0:0] SETB;
endfunction

function LATCHX1 CELL (Q,QN,CLK,D);
output [0:0] Q,QN;
input [0:0] CLK,D;
endfunction

function LATCHX2 CELL (Q,QN,CLK,D);
output [0:0] Q,QN;
input [0:0] CLK,D;
endfunction

function LNANDX1 CELL (Q,QN,RIN,SIN);
output [0:0] Q,QN;
input fb [0:0] RIN,SIN;
endfunction

function LNANDX2 CELL (Q,QN,RIN,SIN);
output [0:0] Q,QN;
input fb [0:0] RIN,SIN;
endfunction

function NMT1 CELL (D,G,S);
input fb [0:0] D,G,S;
endfunction

function NMT2 CELL (D,G,S);
input fb [0:0] D,G,S;
endfunction

function NMT3 CELL (D,G,S);
input fb [0:0] D,G,S;
endfunction

function OAI221X1 CELL (QN,IN1,IN2,IN3,IN4,IN5);
output  QN;
input  IN1,IN2,IN3,IN4,IN5;
endfunction

function OAI221X2 CELL (QN,IN1,IN2,IN3,IN4,IN5);
output  QN;
input  IN1,IN2,IN3,IN4,IN5;
endfunction

function PGX1 CELL (INQ2,INN,INP,INQ1);
output  INQ2;
input fb  INN,INP;
input  INQ1;
endfunction

function PGX2 CELL (INQ2,INN,INP,INQ1);
output  INQ2;
input fb  INN,INP;
input  INQ1;
endfunction

function PGX4 CELL (INQ2,INN,INP,INQ1);
output  INQ2;
input fb  INN,INP;
input  INQ1;
endfunction

function PMT1 CELL (D,G,S);
input fb [0:0] D,G,S;
endfunction

function PMT2 CELL (D,G,S);
input fb [0:0] D,G,S;
endfunction

function PMT3 CELL (D,G,S);
input fb [0:0] D,G,S;
endfunction

function SDFFASRSX1 CELL (Q,QN,S0,CLK,D,RSTB,SE,SETB,SI);
output [0:0] Q,QN,S0;
input [0:0] CLK;
input fb [0:0] D,RSTB,SE,SETB,SI;
endfunction

function SDFFASRSX2 CELL (Q,QN,S0,CLK,D,RSTB,SE,SETB,SI);
output [0:0] Q,QN,S0;
input [0:0] CLK;
input fb [0:0] D,RSTB,SE,SETB,SI;
endfunction

function SDFFASRX1 CELL (Q,QN,CLK,D,RSTB,SE,SETB,SI);
output [0:0] Q,QN;
input [0:0] CLK;
input fb [0:0] D,RSTB,SE,SETB,SI;
endfunction

function SDFFASRX2 CELL (Q,QN,CLK,D,RSTB,SE,SETB,SI);
output [0:0] Q,QN;
input [0:0] CLK;
input fb [0:0] D,RSTB,SE,SETB,SI;
endfunction

function SDFFASX1 CELL (Q,QN,CLK,D,SE,SETB,SI);
output [0:0] Q,QN;
input [0:0] CLK;
input fb [0:0] D,SE,SETB,SI;
endfunction

function SDFFASX2 CELL (Q,QN,CLK,D,SE,SETB,SI);
output [0:0] Q,QN;
input [0:0] CLK;
input fb [0:0] D,SE,SETB,SI;
endfunction

function SDFFNARX1 CELL (Q,QN,CLK,D,RSTB,SE,SI);
output [0:0] Q,QN;
input [0:0] CLK;
input fb [0:0] D,RSTB,SE,SI;
endfunction

function SDFFNARX2 CELL (Q,QN,CLK,D,RSTB,SE,SI);
output [0:0] Q,QN;
input [0:0] CLK;
input fb [0:0] D,RSTB,SE,SI;
endfunction

function SDFFNASRX1 CELL (Q,QN,CLK,D,RSTB,SE,SETB,SI);
output [0:0] Q,QN;
input [0:0] CLK;
input fb [0:0] D,RSTB,SE,SETB,SI;
endfunction

function SDFFNASRX2 CELL (Q,QN,CLK,D,RSTB,SE,SETB,SI);
output [0:0] Q,QN;
input [0:0] CLK;
input fb [0:0] D,RSTB,SE,SETB,SI;
endfunction

function SDFFNASX1 CELL (Q,QN,CLK,D,SE,SETB,SI);
output [0:0] Q,QN;
input [0:0] CLK;
input fb [0:0] D,SE,SETB,SI;
endfunction

function SDFFNASX2 CELL (Q,QN,CLK,D,SE,SETB,SI);
output [0:0] Q,QN;
input [0:0] CLK;
input fb [0:0] D,SE,SETB,SI;
endfunction

function SDFFNX1 CELL (Q,QN,CLK,D,SE,SI);
output [0:0] Q,QN;
input [0:0] CLK;
input fb [0:0] D,SE,SI;
endfunction

function SDFFNX2 CELL (Q,QN,CLK,D,SE,SI);
output [0:0] Q,QN;
input [0:0] CLK;
input fb [0:0] D,SE,SI;
endfunction

function SDFFSSRX1 CELL (Q,QN,CLK,D,RSTB,SE,SETB,SI);
output [0:0] Q,QN;
input [0:0] CLK;
input fb [0:0] D,RSTB,SE,SETB,SI;
endfunction

function SDFFSSRX2 CELL (Q,QN,CLK,D,RSTB,SE,SETB,SI);
output [0:0] Q,QN;
input [0:0] CLK;
input fb [0:0] D,RSTB,SE,SETB,SI;
endfunction

function SDFFX1 CELL (Q,QN,CLK,D,SE,SI);
output [0:0] Q,QN;
input [0:0] CLK;
input fb [0:0] D,SE,SI;
endfunction

function SDFFX2 CELL (Q,QN,CLK,D,SE,SI);
output [0:0] Q,QN;
input [0:0] CLK;
input fb [0:0] D,SE,SI;
endfunction

function SHFILL1 CELL ();
endfunction

function SHFILL128 CELL ();
endfunction

function SHFILL2 CELL ();
endfunction

function SHFILL3 CELL ();
endfunction

function SHFILL64 CELL ();
endfunction

function TIEH CELL (Z);
output  Z;
endfunction

function TIEL CELL (ZN);
output  ZN;
endfunction

function udpeGenerateCmp6Unsigned CELL (out1,out2,out3,out4,out5,out6,in1,in2);
output [1] out1;
output [1] out2;
output [1] out3;
output [1] out4;
output [1] out5;
output [1] out6;
input  in1;
input  in2;
endfunction

function udpeGenerateCmp6Signed CELL (out1,out2,out3,out4,out5,out6,in1,in2);
output [1] out1;
output [1] out2;
output [1] out3;
output [1] out4;
output [1] out5;
output [1] out6;
input  in1;
input  in2;
endfunction

function udpeGenerateCmp2Unsigned CELL (out1,out2,in1,in2,in3);
output [1] out1;
output [1] out2;
input  in1;
input  in2;
input  in3;
endfunction

function udpeGenerateCmp2Signed CELL (out1,out2,in1,in2,in3);
output [1] out1;
output [1] out2;
input  in1;
input  in2;
input  in3;
endfunction

function udpeGenerateCmpUnsignedEq CELL (out1,in1,in2,in3,in4);
output [1] out1;
input  in1;
input  in2;
input  in3;
input  in4;
endfunction

function udpeGenerateCmpUnsignedMag CELL (out1,in1,in2,in3,in4);
output [1] out1;
input  in1;
input  in2;
input  in3;
input  in4;
endfunction

function udpeGenerateCmpSignedEq CELL (out1,in1,in2,in3,in4);
output [1] out1;
input  in1;
input  in2;
input  in3;
input  in4;
endfunction

function udpeGenerateCmpSignedMag CELL (out1,in1,in2,in3,in4);
output [1] out1;
input  in1;
input  in2;
input  in3;
input  in4;
endfunction

function udpeGenerateCmpUnsigned CELL (out1,out2,in1,in2,in3,in4);
output [1] out1;
output [1] out2;
input  in1;
input  in2;
input  in3;
input  in4;
endfunction

function udpeGenerateCmpSigned CELL (out1,out2,in1,in2,in3,in4);
output [1] out1;
output [1] out2;
input  in1;
input  in2;
input  in3;
input  in4;
endfunction

function udpeGenerateSelectopOneHot CELL (out1, repl(i,fnArgs()-1,",") {in{i}});
output out1;
input repl(i,fnArgs()-1,",") {in{i}};
endfunction

function udpeGenerateCSBitTruncation CELL (out1,in1,in2,in3,in4);
output out1;
input  in1;
input  in2;
input  in3;
input  in4;
endfunction
